devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构“入门”—手撕顺序表_手撕数据结构

作者：人工智能uu | 2024-07-24 20:52:10

赞

踩

手撕数据结构

目录

一:顺序表基本概念

二:顺序表的实现

1 创建顺序表

 2 初始化顺序表

3 检查是否需要扩容

4 打印顺序表

5 销毁顺序表

 三:顺序表重要功能—“增 删 查 改”

1:增加数据

1-1：尾插

1-2：头插

 1-3：指定下标插入

2:删除数据

2-1：尾删

2-2：头删

2-3：指定下标删除

 3:查找数据

 4:修改数据

4:源码

5:下篇预告

一:顺序表基本概念

概念及结构：顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

类别: 

1.静态顺序表：使用定长数组存储元素。

 2. 动态顺序表：使用动态开辟的数组存储。

❗：顺序表要求存储的数据是从下标0开始，依次连续存储，中间不能用空位。

接口实现：静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态的分配空间大小，所以下面我们实 现动态顺序表。

二:顺序表的实现

⭐：顺序表代码的实现将放在三个文件中，分别是SeqList.h、SeqList.c、Test.c。分别用于声明，定义，测试。

1 创建顺序表

  • SeqList.h文件：
    1. //创建顺序表
    2.  
    3. typedef int SLDateType; //确保以后想存其它数据类型的时候方便改动，本文以存放整型数据为例
    4.  
    5. typedef struct SeqList
    6. {
    7. 	SLDateType* a; //动态开辟数组
    8. 	int size;      //存储顺序表中有效数据个数
    9. 	int capacity;  //记录开辟空间的容量
    10. }SeqList;

 2 初始化顺序表

  • SeqList.h文件：
    1. //初始化顺序表
    2. void SeqListInit(SeqList* psl);

  • SeqList.c文件：

    1. //初始化顺序表
    2. void SeqListInit(SeqList* psl)
    3. {
    4. 	assert(psl);
    5. 	psl->a = NULL;
    6. 	psl->size = 0;
    7. 	psl->capacity = 0;
    8. }

3 检查是否需要扩容

  • SeqList.h文件：
    1. //检测是否需要扩容
    2. void SeqListCheckCapacity(SeqList* psl);
  • SeqList.c文件：
    1. //检测是否需要扩容
    2. void SeqListCheckCapacity(SeqList* psl)
    3. {
    4. 	assert(psl);
    5. 	//如果满了，就要扩容
    6. 	if (psl->size == psl->capacity)
    7. 	{
    8. 		size_t newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2; //防止原始capacity的容量本身为0，导致后续扩容仍为0
    9. 		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType) * newCapacity);
    10.         //如果psl->a为空指针，此时realloc相当于malloc
    11. 		if (tmp == NULL)
    12. 		{
    13. 			printf("realloc fail\n");
    14. 			exit(-1);
    15. 		}
    16. 		else
    17. 		{
    18. 			psl->a = tmp;
    19. 			psl->capacity = (int)newCapacity;
    20. 		}
    21. 	}
    22. }

4 打印顺序表

  • SeqList.h文件：
    1. //打印顺序表
    2. void SeqListPrint(SeqList* psl);
  • SeqList.c文件：
    1. //打印顺序表
    2. void SeqListPrint(SeqList* psl)
    3. {
    4. 	assert(psl);
    5. 	for (int i = 0; i < psl->size; i++)
    6. 	{
    7. 		printf("%d ",psl->a[i]);
    8. 	}
    9. 	printf("\n");
    10. }

5 销毁顺序表

  • SeqList.h文件：
    1. //销毁顺序表
    2. void SeqListDestroy(SeqList* psl);
  • SeqList.c文件：
    1. //销毁顺序表
    2. void SeqListDestroy(SeqList* psl)
    3. {
    4. 	assert(psl);
    5. 	free(psl->a);
    6. 	psl->a = NULL;
    7. 	psl->capacity = psl->size = 0;
    8. }

 三:顺序表重要功能—“增 删 查 改”

1:增加数据

1-1：尾插

思路：在我们进行插入数据之前我们首先要判断一下自己realloc的空间是否已满，如果满我们需要扩容，未满我们就可以在数组下标为psl->size处插入数据。

  • SeqList.h文件：
    1. //尾插
    2. void SeqListPushBack(SeqList* psl, SLDataType x);
  • SeqList.c文件：
    1. //尾插
    2. void SeqListPushBack(SeqList* psl, SLDataType x)
    3. {
    4. 	assert(psl);
    5. 	SeqListCheckCapacity(psl); //检测容量
    6. 	psl->a[psl->size] = x;
    7. 	psl->size++;
    8. }
  • Test.c文件：
    1. void SeqListTest1()
    2. {
    3. 		SeqList s;
    4. 		SeqListInit(&s); //注意加上&，因为形参的改变不影响实参
    5. 		//尾插5个数字
    6. 		SeqListPushBack(&s, 1);
    7. 		SeqListPushBack(&s, 2);
    8. 		SeqListPushBack(&s, 3);
    9. 		SeqListPushBack(&s, 4);
    10. 		SeqListPushBack(&s, 5);
    11. 		SeqListprint(&s); //打印
    12. }

1-2：头插

思路：头插就是在下标为0的位置插入一个元素，同时把原来的元素往后挪，把第一个位置空出来，同时也要确保空间足够，不够进行扩容。

  • SeqList.h文件：
    1. //头插
    2. void SeqListPushFront(SeqList* psl, SLDataType x);
  • SeqList.c文件：
    1. //头插
    2. void SeqListPushFront(SeqList* psl, SLDataType x)
    3. {
    4. 	assert(psl);
    5. 	SeqListCheckCapacity(psl); //检测容量
    6. 	int end = psl->size;
    7. 	while (end > 0)
    8. 	{
    9. 		psl->a[end] = psl->a[end-1];
    10. 		end--;
    11. 	}
    12. 	psl->a[0] = x;
    13. 	psl->size++;
    14. }
  • Test.c文件：
    1. void SeqListTest2()
    2. {
    3. 	SeqList s;
    4. 	SeqListInit(&s); //注意加上&，因为形参的改变不影响实参
    5. 	//先尾插4个数字
    6. 	SeqListPushBack(&s, 1);
    7. 	SeqListPushBack(&s, 2);
    8. 	SeqListPushBack(&s, 3);
    9. 	SeqListPushBack(&s, 4);
    10. 	SeqListprint(&s); //尾插4次后打印
    11. 	//头插2个数字
    12. 	SeqListPushFront(&s, 0);
    13. 	SeqListPushFront(&s, -1);
    14. 	SeqListprint(&s); //头插2次后打印
    15. }

 1-3：指定下标插入

思路：在有效数据size范围内在指定下标插入想要插入的数据，同时检测是否需要扩容。

  • SeqList.h文件：
    1. //在pos位置插入x
    2. void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
  • SeqList.c文件：
    1. //在pos位置插入x
    2. void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
    3. {
    4. 	assert(psl);
    5. 	//暴力检查
    6. 	/*assert(pos <= psl);*/
    7. 	//温和检查
    8. 	if (pos > psl->size)
    9. 	{
    10. 		printf("pos 越界：%d\n", pos);
    11. 		return;
    12. 	}
    13. 	SeqListCheckCapacity(psl); //检测容量
    14. 	int end = psl->size;
    15. 	while (end > pos)
    16. 	{
    17. 		psl->a[end] = psl->a[end - 1];
    18. 		end--;
    19. 	}
    20. 	psl->a[pos] = x;
    21. 	psl->size++;
    22. }

    Test.c文件：

    1. void SeqListTest3()
    2. {
    3. 	SeqList s;
    4. 	SeqListInit(&s);
    5. 	//先尾插4个数字
    6. 	SeqListPushBack(&s, 1);
    7. 	SeqListPushBack(&s, 2);
    8. 	SeqListPushBack(&s, 3);
    9. 	SeqListPushBack(&s, 4);
    10. 	SeqListprint(&s); //尾插4次后打印
    11. 	//指定下标插入2个数字
    12. 	SeqListInsert(&s, 10, 100);
    13. 	SeqListInsert(&s, 1, 10);
    14. 	SeqListInsert(&s, 3, 20);
    15. 	SeqListprint(&s); //插入成功后打印
    16. }

  • ⭐：当pos=size时，程序实现的就是尾插，所以尾插只是在指定下标插入的一种特殊情况。

    1. //尾插
    2. void SeqListPushBack(SeqList* psl, SLDataType x)
    3. {
    4. 	assert(psl);
    5. //法一：
    6. 	/*SeqListCheckCapacity(psl); //检测容量
    7. 	psl->a[psl->size] = x;
    8. 	psl->size++;*/
    9. //法二：
    10. 	SeqListInsert(psl, psl->size, x);
    11. }

    同理：当pos=0时，实现的就是头插。

    1. //头插
    2. void SeqListPushFront(SeqList* psl, SLDataType x)
    3. {
    4. 	assert(psl);
    5. //法一：
    6. 	/*SeqListCheckCapacity(psl); //检测容量
    7. 	int end = psl->size;
    8. 	while (end > 0)
    9. 	{
    10. 		psl->a[end] = psl->a[end-1];
    11. 		end--;
    12. 	}
    13. 	psl->a[0] = x;
    14. 	psl->size++;*/
    15. //法二：
    16. 	SeqListInsert(psl, 0, x);
    17. }

2:删除数据

2-1：尾删

思路：我们创建的结构体成员size指的是顺序表中有效数据的个数，因为顺序表的下标是从0开始的，而下标size所对应的元素就是最后一位有效数据的下一位，所以我们想要实现尾删只需要把有效数据的个数-1，打印的时候自然会把最后一个数据删掉，如果删除次数过多，有效数据size可能会变成负数，所以我们需要确保在size>0的情况下再减减。

  • SeqList.h文件：
    1. //尾删
    2. void SeqListPopBack(SeqList* psl);
  • SeqList.c文件：
    1. //尾删
    2. void SeqListPopBack(SeqList* psl)
    3. {
    4. 	assert(psl);
    5. 	if (psl->size > 0)
    6. 	{
    7. 		psl->size--;
    8. 	}
  • Test.c文件：
    1. void SeqListTest4()
    2. {
    3. 	SeqList s;
    4. 	SeqListInit(&s); //注意加上&，因为形参的改变不影响实参
    5. 	//尾插5个数字
    6. 	SeqListPushBack(&s, 1);
    7. 	SeqListPushBack(&s, 2);
    8. 	SeqListPushBack(&s, 3);
    9. 	SeqListPushBack(&s, 4);
    10. 	SeqListPushBack(&s, 5);
    11. 	SeqListprint(&s); //尾插5次后打印
    12.  
    13. 	//尾删4个数字
    14. 	//SeqListPopBack(&s);
    15. 	SeqListPopBack(&s);
    16. 	SeqListPopBack(&s);
    17. 	SeqListPopBack(&s);
    18. 	SeqListPopBack(&s);
    19. 	SeqListprint(&s); //尾删4次后打印
    20.  
    21. 	//再尾插2个数字
    22. 	SeqListPushBack(&s, 6);
    23. 	SeqListPushBack(&s, 7);
    24. 	SeqListprint(&s); //再尾插2次打印
    25.  
    26. }

2-2：头删

思路：头删就是去除下标为0的元素，我们只需要把下标1~size-1的元素都向前挪一位即可。同时也要确保size>=0。

  • SeqList.h文件：
    1. //头删
    2. void SeqListPopFront(SeqList* psl);
  • SeqList.c文件：
    1. //头删
    2. void SeqListPopFront(SeqList* psl)
    3. {
    4. 	assert(psl);
    5. 	if (psl->size > 0)
    6. 	{
    7. 		int begin = 1;
    8. 		while (begin < psl->size)
    9. 		{
    10. 			psl->a[begin - 1] = psl->a[begin];
    11. 			begin++;
    12. 		}
    13. 		psl->size--;
    14. 	}
    15. }
  • Test.c文件：
    1. void SeqListTest5()
    2. {
    3. 	SeqList s;
    4. 	SeqListInit(&s);
    5. 	//尾插10个数字
    6. 	for (int i = 1; i <= 10; i++)
    7. 	{
    8. 		SeqListPushBack(&s, i);
    9. 	}
    10. 	SeqListprint(&s); //尾插9个数字后打印
    11. 	//头删12次数据
    12. 	for (int i = 1; i <= 9; i++)
    13. 	{
    14. 		SeqListPopFront(&s);
    15. 	}
    16. 	SeqListprint(&s); //头删12次后打印
    17. 	//头插5个数字
    18. 	for (int i = -5; i <= -1; i++)
    19. 	{
    20. 		SeqListPushFront(&s, i);
    21. 	}
    22. 	SeqListprint(&s); //头插5次后打印
    23. }

2-3：指定下标删除

思路：和头删的思路大致相同，同时确保指定下标pos<size,如果pos=size则是删除了一个无意义的数。

  • SeqList.h文件：
    1. //删除pos位置的数据
    2. void SeqListErase(SeqList* psl, size_t pos);

    SeqList.c文件：

    1. //删除pos位置的数据
    2. void SeqListErase(SeqList* psl, size_t pos)
    3. {
    4. 	assert(psl);
    5. 	assert(pos < psl->size);
    6. 	size_t begin = pos + 1;
    7. 	while (begin < psl->size)
    8. 	{
    9. 		psl->a[begin - 1] = psl->a[begin];
    10. 		++begin;
    11. 	}
    12. 	psl->size--;
    13. }

    Test.c文件：

    1. void SeqListTest6()
    2. {
    3. 	SeqList s;
    4. 	SeqListInit(&s);
    5. 	//先尾插4个数字
    6. 	SeqListPushBack(&s, 1);
    7. 	SeqListPushBack(&s, 2);
    8. 	SeqListPushBack(&s, 3);
    9. 	SeqListPushBack(&s, 4);
    10. 	SeqListprint(&s); //尾插4次后打印
    11. 	//删除2个指定下标的数字
    12. 	SeqListErase(&s, 1);//下标1
    13. 	SeqListErase(&s, 2);//下标2
    14. 	SeqListprint(&s); //删除后打印
    15. }

  • ⭐：当pos=0时，删除的就是下标为0的元素，此时实现的就是头删。

    1. //头删
    2. void SeqListPopFront(SeqList* psl)
    3. {
    4. 	assert(psl);
    5. //法一：
    6. 	/*if (psl->size > 0)
    7. 	{
    8. 		int begin = 1;
    9. 		while (begin < psl->size)
    10. 		{
    11. 			psl->a[begin - 1] = psl->a[begin];
    12. 			begin++;
    13. 		}
    14. 		psl->size--;
    15. 	}*/
    16. //法二：指定下标删除法
    17. 	SeqListErase(psl, 0);
    18. }

    而当pos=size-1时，实现的就是尾删。

 3:查找数据

思路：遍历数组即可。

  • SeqList.h文件：
    1. //查找指定数字
    2. int SeqListFind(SeqList* psl, SLDataType x);
  • SeqList.c文件：
    1. //查找指定数字
    2. int SeqListFind(SeqList* psl, SLDataType x)
    3. {
    4. 	assert(psl);
    5. 	for (int i = 0; i < psl->size; i++)
    6. 	{
    7. 		if (psl->a[i] == x)
    8. 		{
    9. 			return i;
    10. 		}
    11. 	}
    12. 	return -1;
    13. }
  • Test.c文件：
    1. void SeqListTest7()
    2. {
    3. 	SeqList s;
    4. 	SeqListInit(&s);
    5. 	//先尾插4个数字
    6. 	SeqListPushBack(&s, 1);
    7. 	SeqListPushBack(&s, 2);
    8. 	SeqListPushBack(&s, 3);
    9. 	SeqListPushBack(&s, 4);
    10. 	SeqListprint(&s); //尾插4次后打印
    11. 	int pos = SeqListFind(&s, 2);
    12. 	if (pos != -1)
    13. 		printf("找到了，下标是：%d", pos);
    14. 	else
    15. 		printf("找不到\n");
    16. }

 4:修改数据

思路：在有效数据范围内将指定下标元素进行修改即可。

  • SeqList.h文件：
    1. //修改指定下标数字
    2. void SeqListModify(SeqList* psl, size_t pos, SLDataType x);
  • SeqList.c文件：
    1. //修改指定下标数字
    2. void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
    3. {
    4. 	assert(psl);
    5. 	assert(pos < psl->size);
    6. 	psl->a[pos] = x;
    7. }
  • Test.c文件：
    1. void SeqListTest8()
    2. {
    3. 	SeqList s;
    4. 	SeqListInit(&s);
    5. 	//先尾插4个数字
    6. 	SeqListPushBack(&s, 1);
    7. 	SeqListPushBack(&s, 2);
    8. 	SeqListPushBack(&s, 3);
    9. 	SeqListPushBack(&s, 4);
    10. 	SeqListprint(&s); //尾插4次后打印
    11. 	SeqListModify(&s, 1, 5);
    12. 	SeqListprint(&s); //修改后打印
    13. }

4:源码

SeqList.h

  1. #pragma once
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <assert.h>
  6.  
  7. //创建顺序表
  8.  
  9. typedef int SLDataType; //确保以后想存其它数据类型的时候方便改动，本文以存放整型数据为例
  10.  
  11. typedef struct SeqList
  12. {
  13. 	SLDataType* a; //动态开辟数组
  14. 	int size;      //存储顺序表中有效数据个数
  15. 	int capacity;  //记录开辟空间的容量
  16. }SeqList;
  17.  
  18. //初始化顺序表
  19. void SeqListInit(SeqList* psl);
  20.  
  21. //销毁顺序表
  22. void SeqListDestory(SeqList* psl);
  23.  
  24. //打印顺序表
  25. void SeqListprint(SeqList* psl);
  26.  
  27. //检查是否扩容
  28. void SeqListCheckCapacity(SeqList* psl);
  29. //尾插和尾删的时间复杂度为0(1)
  30. //尾插
  31. void SeqListPushBack(SeqList* psl, SLDataType x);
  32.  
  33. //尾删
  34. void SeqListPopBack(SeqList* psl);
  35. //头插和头删的时间复杂度为0(N)
  36. //头插
  37. void SeqListPushFront(SeqList* psl, SLDataType x);
  38.  
  39. //头删
  40. void SeqListPopFront(SeqList* psl);
  41.  
  42. //在pos位置插入x
  43. void SeqListInsert(SeqList* psl, size_t pos, SLDataType x);
  44.  
  45. //删除pos位置的数据
  46. void SeqListErase(SeqList* psl, size_t pos);
  47.  
  48. //查找顺序表中的元素
  49. int SeqListFind(SeqList* psl, SLDataType x);
  50.  
  51. //修改指定下标数字
  52. void SeqListModify(SeqList* psl, size_t pos, SLDataType x);

SeqList.c

  1. #include "SeqList.h"
  2.  
  3. //初始化顺序表
  4. void SeqListInit(SeqList* psl)
  5. {
  6. 	assert(psl);
  7. 	psl->a = NULL;
  8. 	psl->size = 0;
  9. 	psl->capacity = 0;
  10. }
  11.  
  12. //打印顺序表
  13. void SeqListprint(SeqList* psl)
  14. {
  15. 	assert(psl);
  16. 	for (int i = 0; i < psl->size; i++)
  17. 	{
  18. 		printf("%d ", psl->a[i]);
  19. 	}
  20. 	printf("\n");
  21. }
  22.  
  23. //销毁顺序表
  24. void SeqListDestory(SeqList* psl)
  25. {
  26. 	assert(psl);
  27. 	free(psl->a);
  28. 	psl->a = NULL;
  29. 	psl->capacity = psl->size = 0;
  30. }
  31.  
  32. //检查是否扩容
  33. void SeqListCheckCapacity(SeqList* psl)
  34. {
  35. 	assert(psl);
  36. 	//如果满了，我们要扩容
  37. 	if (psl->size == psl->capacity)
  38. 	{
  39. 		size_t newCapacity = psl->capacity == 0 ? 4 : psl->capacity * 2;
  40. 		SLDataType* tmp = realloc(psl->a, sizeof(SLDataType) * newCapacity);
  41. 		if (tmp == NULL)
  42. 		{
  43. 			printf("realloc fail\n");
  44. 			exit(-1);
  45. 		}
  46. 		else
  47. 		{
  48. 			psl->a = tmp;
  49. 			psl->capacity = newCapacity;
  50. 		}
  51. 	}
  52. }
  53.  
  54. //尾插
  55. void SeqListPushBack(SeqList* psl, SLDataType x)
  56. {
  57. 	assert(psl);
  58. 	//法一
  59. 	//SeqListCheckCapacity(psl); //检测容量
  60. 	//psl->a[psl->size] = x;
  61. 	//psl->size++;
  62. 	//法二
  63. 	SeqListInsert(psl, psl->size, x);
  64. }
  65.  
  66. //尾删
  67. void SeqListPopBack(SeqList* psl)
  68. {
  69. 	assert(psl);
  70. 	//这里必须在size大于0的情况下完成尾删
  71. 	if (psl->size > 0)
  72. 	{
  73. 		(psl->size)--;
  74. 	}
  75. }
  76.  
  77. //头插
  78. void SeqListPushFront(SeqList* psl, SLDataType x)
  79. {
  80. 	assert(psl);
  81. 	//法一
  82. 	/*SeqListCheckCapacity(psl);
  84. 	int end = psl->size;
  85. 	while (end > 0)
  86. 	{
  87. 		psl->a[end] = psl->a[end-1];
  88. 		end--;
  89. 	}
  90. 	psl->a[0] = x;
  91. 	psl->size++;*/
  92. 	//法二
  93. 	SeqListInsert(psl, 0, x);
  94. }
  95.  
  96. //头删
  97. void SeqListPopFront(SeqList* psl)
  98. {
  99. 	assert(psl);
  100. 	//法一
  101. 	/*if (psl->size > 0)
  102. 	{
  103. 		int begin = 1;
  104. 		while (begin < psl->size)
  105. 		{
  106. 			psl->a[begin - 1] = psl->a[begin];
  107. 			begin++;
  108. 		}
  109. 		psl->size--;
  110. 	}*/
  111. 	//法二
  112. 	SeqListErase(psl, 0);
  113. }
  114.  
  115. //在pos位置插入x
  116. void SeqListInsert(SeqList* psl, size_t pos, SLDataType x)
  117. {
  118. 	assert(psl);
  119. 	//暴力检查
  120. 	/*assert(pos <= psl);*/
  121. 	//温和检查
  122. 	if (pos > psl->size)
  123. 	{
  124. 		printf("pos 越界：%d\n", pos);
  125. 		return;
  126. 	}
  127. 	SeqListCheckCapacity(psl); //检测容量
  128. 	int end = psl->size;
  129. 	while (end > pos)
  130. 	{
  131. 		psl->a[end] = psl->a[end - 1];
  132. 		end--;
  133. 	}
  134. 	psl->a[pos] = x;
  135. 	psl->size++;
  136. }
  137.  
  138. //删除pos位置的数据
  139. void SeqListErase(SeqList* psl, size_t pos)
  140. {
  141. 	assert(psl);
  142. 	assert(pos < psl->size);
  143. 	
  144. 	size_t begin = pos + 1;
  145. 	while (begin < psl->size)
  146. 	{
  147. 		psl->a[begin - 1] = psl->a[begin];
  148. 		begin++;
  149. 	}
  150. 	psl->size--;
  151. }
  152.  
  153. //查找顺序表中的元素
  154. int SeqListFind(SeqList* psl, SLDataType x)
  155. {
  156. 	assert(psl);
  157.  
  158. 	for (int i = 0; i < psl->size; i++)
  159. 	{
  160. 		if (psl->a[i] == x)
  161. 		{
  162. 			return i;
  163. 		}
  164. 	}
  165. 	return -1;
  166. }
  167.  
  168. //修改指定下标数字
  169. void SeqListModify(SeqList* psl, size_t pos, SLDataType x)
  170. {
  171. 	assert(psl);
  172. 	assert(pos < psl->size);
  173. 	psl->a[pos] = x;
  174. }

test.c

  1. #include "SeqList.h"
  2.  
  3. void SeqListTest1()
  4. {
  5. 		SeqList s;
  6. 		SeqListInit(&s); //注意加上&，因为形参的改变不影响实参
  7. 		//尾插5个数字
  8. 		SeqListPushBack(&s, 1);
  9. 		SeqListPushBack(&s, 2);
  10. 		SeqListPushBack(&s, 3);
  11. 		SeqListPushBack(&s, 4);
  12. 		SeqListPushBack(&s, 5);
  13. 		SeqListprint(&s); //打印
  14. }
  15.  
  16. void SeqListTest2()
  17. {
  18. 	SeqList s;
  19. 	SeqListInit(&s); //注意加上&，因为形参的改变不影响实参
  20. 	//先尾插4个数字
  21. 	SeqListPushBack(&s, 1);
  22. 	SeqListPushBack(&s, 2);
  23. 	SeqListPushBack(&s, 3);
  24. 	SeqListPushBack(&s, 4);
  25. 	SeqListprint(&s); //尾插4次后打印
  26. 	//头插2个数字
  27. 	SeqListPushFront(&s, 0);
  28. 	SeqListPushFront(&s, -1);
  29. 	SeqListprint(&s); //头插2次后打印
  30. }
  31.  
  32. void SeqListTest3()
  33. {
  34. 	SeqList s;
  35. 	SeqListInit(&s); //注意加上& ，因为形参的改变不影响实参
  36. 	//先尾插4个数字
  37. 	SeqListPushBack(&s, 1);
  38. 	SeqListPushBack(&s, 2);
  39. 	SeqListPushBack(&s, 3);
  40. 	SeqListPushBack(&s, 4);
  41. 	SeqListprint(&s); //尾插4次后打印
  42. 	//指定下标插入2个数字
  43. 	SeqListInsert(&s, 10, 100);
  44. 	SeqListInsert(&s, 1, 10);
  45. 	SeqListInsert(&s, 3, 20);
  46. 	SeqListprint(&s); //插入成功后打印
  47. }
  48.  
  49. void SeqListTest4()
  50. {
  51. 	SeqList s;
  52. 	SeqListInit(&s); //注意加上&，因为形参的改变不影响实参
  53. 	//尾插5个数字
  54. 	SeqListPushBack(&s, 1);
  55. 	SeqListPushBack(&s, 2);
  56. 	SeqListPushBack(&s, 3);
  57. 	SeqListPushBack(&s, 4);
  58. 	SeqListPushBack(&s, 5);
  59. 	SeqListprint(&s); //尾插5次后打印
  60.  
  61. 	//尾删4个数字
  62. 	//SeqListPopBack(&s);
  63. 	SeqListPopBack(&s);
  64. 	SeqListPopBack(&s);
  65. 	SeqListPopBack(&s);
  66. 	SeqListPopBack(&s);
  67. 	SeqListprint(&s); //尾删4次后打印
  68.  
  69. 	//再尾插2个数字
  70. 	SeqListPushBack(&s, 6);
  71. 	SeqListPushBack(&s, 7);
  72. 	SeqListprint(&s); //再尾插2次打印
  73.  
  74. }
  75.  
  76. void SeqListTest5()
  77. {
  78. 	SeqList s;
  79. 	SeqListInit(&s);
  80. 	//尾插10个数字
  81. 	for (int i = 1; i <= 10; i++)
  82. 	{
  83. 		SeqListPushBack(&s, i);
  84. 	}
  85. 	SeqListprint(&s); //尾插10个数字后打印
  86. 	//头删12次数据
  87. 	for (int i = 1; i <= 9; i++)
  88. 	{
  89. 		SeqListPopFront(&s);
  90. 	}
  91. 	SeqListprint(&s); //头删12次后打印
  92. 	//头插5个数字
  93. 	for (int i = -5; i <= -1; i++)
  94. 	{
  95. 		SeqListPushFront(&s, i);
  96. 	}
  97. 	SeqListprint(&s); //头插5次后打印
  98. }
  99.  
  100. void SeqListTest6()
  101. {
  102. 	SeqList s;
  103. 	SeqListInit(&s);
  104. 	//先尾插4个数字
  105. 	SeqListPushBack(&s, 1);
  106. 	SeqListPushBack(&s, 2);
  107. 	SeqListPushBack(&s, 3);
  108. 	SeqListPushBack(&s, 4);
  109. 	SeqListprint(&s); //尾插4次后打印
  110. 	//删除2个指定下标的数字
  111. 	SeqListErase(&s, 1);//下标1
  112. 	SeqListErase(&s, 2);//下标2
  113. 	SeqListprint(&s); //删除后打印
  114. }
  115.  
  116. void SeqListTest7()
  117. {
  118. 	SeqList s;
  119. 	SeqListInit(&s);
  120. 	//先尾插4个数字
  121. 	SeqListPushBack(&s, 1);
  122. 	SeqListPushBack(&s, 2);
  123. 	SeqListPushBack(&s, 3);
  124. 	SeqListPushBack(&s, 4);
  125. 	SeqListprint(&s); //尾插4次后打印
  126. 	int pos = SeqListFind(&s, 2);
  127. 	if (pos != -1)
  128. 		printf("找到了，下标是：%d", pos);
  129. 	else
  130. 		printf("找不到\n");
  131. }
  132.  
  133. void SeqListTest8()
  134. {
  135. 	SeqList s;
  136. 	SeqListInit(&s);
  137. 	//先尾插4个数字
  138. 	SeqListPushBack(&s, 1);
  139. 	SeqListPushBack(&s, 2);
  140. 	SeqListPushBack(&s, 3);
  141. 	SeqListPushBack(&s, 4);
  142. 	SeqListprint(&s); //尾插4次后打印
  143. 	SeqListModify(&s, 1, 5);
  144. 	SeqListprint(&s); //修改后打印
  145. }
  146.  
  147. int main()
  148. {
  149. 	/*SeqListTest1();
  150. 	SeqListTest2();
  151. 	SeqListTest3();
  152. 	SeqListTest4();
  153. 	SeqListTest5();*/
  154. 	/*SeqListTest6();*/
  155. 	/*SeqListTest7();*/
  156. 	SeqListTest8();
  157. 	return 0;
  158. }

5:下篇预告

(　o=^•ェ•)o　下篇我们将使用顺序表刷leetcode相关习题，我们不见不散

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/876692
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。