• 数据结构--顺序表的增删查改--动态分配空间

    一共有两份代码：

    目录

    第一份 分为 两个.c文件和一个.h文件

    1、定义顺序表结构体和宏定义数据类型

    2、顺序表的初始化

    3、顺序表的摧毁（使用完需要摧毁顺序表）

    4、顺序表元素的查找

    5、检查ps的空间是否满了，如果满了则要重新分配空间

    6、在pos位置插入数据

    7、在pos位置删除数据

    8、在头部插入数据

    9、在头部删除数据

    10、在尾部删除数据

    11、在尾部插入数据

    12、代码（全）

    第二份 一个.c文件就可以运行

    第一个分为 两个.c文件和一个.h文件

    1. 说明：
    2.  
    3. assert(ps)表示如果ps为空，会立即报错，使用这个函数一般要加头文件#include
    4.  
    5. ps表示SL类型的结构体，相当于顺序表
    6.  
    7. SeqList.h文件（头文件）存放函数的声明
    8. SeqList.c文件(源文件)存放函数的定义
    9. Seqtext.c存放主函数

    1、定义顺序表结构体和宏定义数据类型

    1. typedef int SLDateType;    //数据类型
    2. typedef struct SeqList
    3. {
    4. 	SLDateType* a;         //数据类型指针，指向动态开辟的数组
    5. 	int size;              //顺序表长度
    6. 	int capacity;          //顺序表容量
    7. }SL;

    2、顺序表的初始化

    1.  
    2.  
    3. void SLInsert(SL* ps)     //顺序表的初始化
    4. {
    5. 	assert(ps);
    6.  
    7. 	ps->a = NULL;
    8. 	ps->size = 0;
    9. 	ps->capacity = 0;
    10. }

    3、顺序表的摧毁（使用完需要摧毁顺序表）

    1.  
    2. void SLDestroy(SL* ps)  //顺序表的摧毁
    3. {
    4. 	assert(ps);
    5. 	if (ps->a)          //如果ps->a不为空
    6. 	{
    7. 		free(ps->a);//释放掉pa->a空间
    8. 		ps->a = NULL;
    9. 		ps->size = ps->capacity = 0;
    10. 	}
    11. }

    4、顺序表元素的查找

    1. int  SLFind(SL* ps, SLDataType x)
    2. {
    3. 	assert(ps);
    4. 	for (int i = 0; i < ps->size; ++i)
    5. 	{
    6. 		if (ps->a[i] == x)
    7. 		{
    8. 			return i;
    9. 		}
    10. 	}
    11. 	return -1;
    12. }

    如果找到了需要找的值，返回值的下标，否者返回-1;

    5、检查ps的空间是否满了，如果满了则要重新分配空间

    1.  
    2. void SLCheckCapacity(SL*ps)
    3. {
    4. 	assert(ps);
    5. 	if (ps->size == ps->capacity)
    6. 	{
    7. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    8. 		SLDataType *tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));//把新添加的用量添加到ps->a里面,这里注意tmp是地址空间
    9. 		if (tmp == NULL)
    10. 		{
    11. 			perror("realloc fail");
    12. 			exit(-1);
    13. 		}
    14. 		ps->a = tmp;
    15. 		ps->capacity = newCapacity;
    16. 	}
    17. }

    刚开始初始化顺序表之后，也通过这个函数分配空间；在这里说一下realloc的作用：

    1.  (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType))表示
    2. 给指向ps->a的指针分配一个大小为newCapacity * sizeof(SLDataType)大小
    3. 的空间，如果在原来指向ps->a的后面的空间被占用了，
    4. 则会异地开辟新的空间，
    5. 并且会拷贝原来的数据过来，而原来的空间会被释放掉。

    6、在pos位置插入数据

    1. //在pos 位置插入x
    2. void SeqListInsert(SeqList* ps, int pos, SLDateType x)
    3. {
    4. 	assert(ps);
    5. 	assert(pos>= 0);
    6. 	assert(pos <= ps->size);                               //此处可以等于0,因为在插入之前ps->a[size]的值为0
    7.  
    8. 	SeqListCheckCapacity(ps);
    9. 	int end = ps->size-1;
    10. 	while (end>=pos)
    11. 	{
    12. 		ps->a[end+1] = ps->a[end];
    13. 		end--;
    14. 	}
    15. 	ps->a[pos] = x;
    16. 	ps->size++;
    17. }

    在插入数据之前需要考虑顺序表容量有没有满：SEqListCheckCapacity(ps);如果没有满，则将在pos位置往后的数据往后挪，挪完之后再插入数据x;

    7、在pos位置删除数据

    1. //删除pos位置数据
    2. void SLErase(SL* ps, int pos)
    3. {
    4. 	assert(ps);
    5. 	assert(pos >= 0);
    6. 	assert(pos < ps->size);
    7. 	int begin = pos + 1;
    8. 	while (begin < ps->size)
    9. 	{
    10. 		ps->a[begin - 1] = ps->a[begin];
    11. 		begin++;
    12. 	}
    13. 	ps->size--;
    14. }

    8、在头部插入数据

    1. void SLPushFront(SL* ps, SLDataType x)   //头插
    2. {
    3. 	SLInsert(ps, 0, x);
    4. }

    9、在头部删除数据

    1. void SLPopFront(SL* ps)   //头删
    2. {
    3. 	SLErase(ps, 0);
    4. }

    10、在尾部删除数据

    1.  
    2. void SLPopBack(SL* ps)                   //尾删除
    3. {
    4. 	SLErase(ps, ps->size-1);
    5. }

    11、在尾部插入数据

    1. void SLPushBack(SL* ps, SLDataType x)           //尾插入
    2. {
    3. 	SLInsert(ps, ps->size, x);
    4. }

    12、代码（全）

    这个是.h文件(头文件)，用来存放函数的声明和顺序表结构体的定义，引用头文件的时候记得加上#include"SeqList.h"

    1. //SeqList.h
    2. #pragma once
    3. #include
    4. #include
    5. #include
    6.  
    7. //静态顺序表---不太实用
    8. //N太小了不够用，N大了可能浪费
    9. //#define  N 1000
    10. //动态顺序表---按需扩空间
    11. typedef int SLDataType;
    12. typedef struct SeqList
    13. {
    14. 	SLDataType* a;
    15. 	int size;            //记录存储多少个有效数据
    16. 	int capacity;        //空间容量大小
    17. }SL;
    18.  
    19. void SLInsert(SL* ps, int pos, SLDataType x);
    20. void SLErase(SL* ps, int pos);
    21.  
    22. void SLPrint(SL* ps);
    23. void SLInit(SL* ps);
    24. void SLDestroy(SL* ps);
    25. void SLCheckCapacity(SL* ps);    //检查容量
    26.  
    27. //尾插尾删
    28. void SLPushBack(SL* ps, SLDataType x);
    29. void SLPopBack(SL* ps);
    30.  
    31. //头插头删
    32. void SLPushFront(SL* ps, SLDataType x);
    33. void SLPopFront(SL* ps);
    34.  
    35. void menu();
    36. int SLFind(SL* ps, SLDataType x, int begin);

     以下是SeqLIst.c文件，存放函数的定义

    1. //SeqList.c
    2. #define  _CRT_SECURE_NO_WARNINGS
    3. #pragma once
    4. #include"SeqList.h"
    5.  
    6. void SLCheckCapacity(SL*ps)
    7. {
    8. 	assert(ps);
    9. 	if (ps->size == ps->capacity)
    10. 	{
    11. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    12. 		SLDataType *tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));//把新添加的用量添加到ps->a里面,这里注意tmp是地址空间
    13. 		if (tmp == NULL)
    14. 		{
    15. 			perror("realloc fail");
    16. 			exit(-1);
    17. 		}
    18. 		ps->a = tmp;
    19. 		ps->capacity = newCapacity;
    20. 	}
    21. }
    22.  
    23. void SLPrint(SL* ps)     //打印
    24. {
    25. 	assert(ps);
    26. 	for (int i = 0; i < ps->size; ++i)
    27. 	{
    28. 		printf(" %d", ps->a[i]);
    29. 	}
    30. 	printf("\n");
    31. }
    32.  
    33. void SLInit(SL* ps)     //顺序表的初始化
    34. {
    35. 	assert(ps);
    36.  
    37. 	ps->a = NULL;
    38. 	ps->size = 0;
    39. 	ps->capacity = 0;
    40. }
    41.  
    42. void SLDestroy(SL* ps)  //顺序表的摧毁
    43. {
    44. 	assert(ps);
    45. 	if (ps->a)          //如果ps->a有值在里面
    46. 	{
    47. 		free(ps->a);//释放掉pa->a空间
    48. 		ps->a = NULL;
    49. 		ps->size = ps->capacity = 0;
    50. 	}
    51. }
    52.  
    53. //在pos位置插入数据
    54. void SLInsert(SL *ps,int pos,SLDataType x)
    55. {
    56. 	assert(ps);
    57. 	assert(pos >= 0);
    58. 	assert(pos <= ps->size);
    59.  
    60. 	SLCheckCapacity(ps);
    61. 	int end = ps->size - 1;
    62. 	while (end >= pos)
    63. 	{
    64. 		ps->a[end + 1] = ps->a[end];
    65. 		end--;
    66. 	}
    67. 	ps->a[pos] = x;
    68. 	ps->size++;
    69. }
    70.  
    71. //删除pos位置数据
    72. void SLErase(SL* ps, int pos)
    73. {
    74. 	assert(ps);
    75. 	assert(pos >= 0);
    76. 	assert(pos < ps->size);
    77. 	int begin = pos + 1;
    78. 	while (begin < ps->size)
    79. 	{
    80. 		ps->a[begin - 1] = ps->a[begin];
    81. 		begin++;
    82. 	}
    83. 	ps->size--;
    84. }
    85.  
    86. void SLPushBack(SL* ps, SLDataType x)           //尾插入
    87. {
    88. 	SLInsert(ps, ps->size, x);
    89. }
    90.  
    91. void SLPopBack(SL* ps)                   //尾删除
    92. {
    93. 	SLErase(ps, ps->size-1);
    94. }
    95. void SLPushFront(SL* ps, SLDataType x)   //头插
    96. {
    97. 	SLInsert(ps, 0, x);
    98. }
    99.  
    100. void SLPopFront(SL* ps)   //头删
    101. {
    102. 	SLErase(ps, 0);
    103. }
    104.  
    105. int  SLFind(SL* ps, SLDataType x, int begin)
    106. {
    107. 	assert(ps);
    108. 	for (int i = begin; i < ps->size; ++i)
    109. 	{
    110. 		if (ps->a[i] == x)
    111. 		{
    112. 			return i;
    113. 		}
    114. 	}
    115. 	return -1;
    116. }

     以下是用来存放主函数的文件，以及一些函数的调用

    1. //SLtest.c
    2. #define  _CRT_SECURE_NO_WARNINGS
    3. #include"SeqList.h"
    4. void menu()
    5. {
    6. 	printf("***********************************************************\n");
    7. 	printf("1、尾插数据 2、尾删数据\n");
    8. 	printf("3、头插数据 4、头删数据\n");
    9. 	printf("5打印数据  -1退出\n");
    10. 	printf("***********************************************************\n");
    11. }
    12. int main()
    13. {
    14. 	SL ps;
    15. 	SLInit(&ps);             //顺序表的初始化
    16. 	//SLInsert(&ps,0,1);
    17. 	//SLPrint(&ps);
    18. 	int n=0;
    19. 	int option=0;
    20. 	do
    21. 	{
    22. 		menu();
    23. 		printf("输入操作\n");
    24. 		scanf("%d", &option);
    25. 		switch (option)
    26. 		{
    27. 		case 1: 
    28. 				printf("请输入你尾插的数据，以-1结束");
    29. 				scanf("%d",&n);
    30. 				while (n != -1)
    31. 				{
    32. 				SLPushBack(&ps,n);
    33. 				scanf("%d",&n);
    34. 				}
    35. 				break;
    36. 		case 2:
    37. 				SLPopBack(&ps);
    38. 				break;
    39. 		case 3:
    40. 				printf("请输入你头插入的数据，以-1结束\n");
    41. 				scanf("%d", &n);
    42. 				while (n != -1)
    43. 				{
    44. 				SLPushFront(&ps,n);
    45. 				scanf("%d", &n);
    46. 				}
    47. 				break;
    48. 		case 4:
    49. 				SLPopFront(&ps);
    50. 				break;
    51. 		case 5:
    52. 				SLPrint(&ps);
    53. 				break;
    54. 		default:
    55. 				break;
    56. 		}
    57. 	} while (option != -1);
    58. 	printf("????\n");
    59. 	SLDestroy(&ps);
    60. 	return 0;
    61. }

    第二份 一个.c文件就可以运行

    (将代码复制到.c文件就可以运行)

    1. #define  _CRT_SECURE_NO_WARNINGS
    2. #pragma once
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. typedef int SLDateType;
    8. typedef struct SeqList
    9. {
    10. 	SLDateType* a;
    11. 	int size;
    12. 	int capacity;
    13. }SeqList;
    14.  
    15. // 对数据的管理:增删查改 
    16. void SeqListInit(SeqList* ps);
    17. void SeqListDestroy(SeqList* ps);
    18.  
    19. void SeqListPrint(SeqList* ps);
    20. void SeqListPushBack(SeqList* ps, SLDateType x);
    21. void SeqListPushFront(SeqList* ps, SLDateType x);
    22. void SeqListPopFront(SeqList* ps);
    23. void SeqListPopBack(SeqList* ps);
    24.  
    25. // 顺序表查找
    26. int SeqListFind(SeqList* ps, SLDateType x);
    27. // 顺序表在pos位置插入x
    28. void SeqListInsert(SeqList* ps, int pos, SLDateType x);
    29. // 顺序表删除pos位置的值
    30.  
    31. void SeqListInit(SeqList* ps)//初始化
    32. {
    33. 	ps->a = NULL;
    34. 	ps->size = 0;
    35. 	ps->capacity = 0;
    36. }
    37.  
    38. void SeqListDestroy(SeqList* ps)
    39. {
    40. 	assert(ps);
    41. 	if (ps->a)
    42. 	{
    43. 		free(ps->a);
    44. 		ps->a = NULL;               //指针制空，释放
    45. 		ps->size = ps->capacity = 0;
    46. 	}
    47. }
    48.  
    49. void SeqPrint(SeqList* ps)          //打印
    50. {
    51. 	int i;
    52. 	assert(ps);
    53. 	for (i = 0; i < ps->size; i++)
    54. 	{
    55. 		printf(" %d", ps->a[i]);
    56. 	}
    57. }
    58. void SeqListCheckCapacity(SeqList* ps)          //给ps->a 分配空间或者添加空间
    59. {
    60. 	assert(ps);
    61. 	if (ps->size == ps->capacity)              //当顺序表长度等于顺序表的容量的时候
    62. 	{
    63. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
    64. 		SLDateType* temp = (SLDateType*)realloc(ps->a, newCapacity * sizeof(SLDateType));
    65. 		if (temp == NULL)                       //if里面用的是"=="
    66. 		{
    67. 			printf("realloc failed");
    68. 			exit(-1);
    69. 		}
    70. 		ps->a = temp;
    71. 		ps->capacity = newCapacity;
    72. 	}
    73.  
    74. }
    75.  
    76. //在pos位置删除数据
    77. void SeqListErase(SeqList* ps, int pos)
    78. {
    79. 	assert(ps);
    80. 	assert(pos >= 0);
    81. 	assert(pos < ps->size);
    82.  
    83. 	int begin = pos + 1;
    84. 	while (begin < ps->size)
    85. 	{
    86. 		ps->a[begin--] = ps->a[begin];        //pos位置的数据被它后一位的数据覆盖
    87. 		begin++;
    88. 	}
    89. 	ps->size--;
    90. }
    91. //在pos 位置插入x
    92. void SeqListInsert(SeqList* ps, int pos, SLDateType x)
    93. {
    94. 	assert(ps);
    95. 	assert(pos>= 0);
    96. 	assert(pos <= ps->size);                               //此处可以等于0,因为在插入之前ps->a[size]的值为0
    97.  
    98. 	SeqListCheckCapacity(ps);
    99. 	int end = ps->size-1;
    100. 	while (end>=pos)
    101. 	{
    102. 		ps->a[end+1] = ps->a[end];
    103. 		end--;
    104. 	}
    105. 	ps->a[pos] = x;
    106. 	ps->size++;
    107. }
    108. void SeqListPushBack(SeqList* ps,SLDateType x)       //尾插
    109. {
    110. 	SeqListInsert(ps, ps->size, x); //相当于在位置ps->a[size]处插入值x
    111. }
    112. void SeqListPopBack(SeqList* ps)                    //尾删
    113. {
    114. 	SeqListErase(ps, ps->size - 1);//相当于在位置ps->a[size-1]处删除数据
    115. }
    116. void SeqListPushFront(SeqList* ps, SLDateType x)   //头插
    117. {
    118. 	SeqListInsert(ps, 0, x);
    119. }
    120. void SeqListPopFront(SeqList* ps)                  //头删
    121. {
    122. 	SeqListErase(ps, 0);
    123. }
    124. int SeqListFind(SeqList* ps, SLDateType x)         //查找元素
    125. {
    126. 	assert(ps);
    127. 	for (int i = 0; i < ps->size; ++i)
    128. 	{
    129. 		if (ps->a[i] == x)
    130. 		{
    131. 			return i;   //返回下标
    132. 		}
    133. 	}
    134. 	return -1; //若返回-1则找不到
    135. }
    136.  
    137. int main()
    138. {
    139. 	SeqList ps;
    140. 	int op;
    141. 	int x;
    142. 	int find;
    143. 	SeqListInit(&ps);                             //初始化
    144. 	do
    145. 	{
    146. 		printf("\n1、尾插 2、尾删 3、头插 4、头删 5、查找元素下标 6、打印 -1、退出\n");
    147. 		printf("输入你的操作:\n");
    148. 		scanf("%d", &op);
    149. 		switch (op)
    150. 		{
    151. 		case 1:
    152. 			printf("请输入你尾删的数据，以-1结束\n");
    153. 			scanf("%d", &x);
    154. 			while (x != -1)
    155. 			{
    156. 				SeqListPushBack(&ps, x);
    157. 				scanf("%d", &x);
    158. 			}
    159. 			break;
    160. 		case 2:
    161. 			SeqListPopBack(&ps); break;
    162. 		case 3:
    163. 			printf("请输入你头插的数据，以-1结束\n");
    164. 			scanf("%d", &x);
    165. 			while (x != -1)
    166. 			{
    167. 				SeqListPushFront(&ps, x);
    168. 				scanf("%d", &x);
    169. 			}
    170. 			break;
    171. 		case 4:
    172. 			SeqListPopFront(&ps); break;
    173. 		case 5:
    174. 			printf("请输入你要查找的元素x=");
    175. 			scanf("%d", &x);
    176. 			if ((find = SeqListFind(&ps, x)) == -1)
    177. 			{
    178. 				printf("没有该元素\n");
    179. 			}
    180. 			else
    181. 				printf("下标为%d", SeqListFind(&ps,x));
    182. 			break;
    183. 		case 6:
    184. 			SeqPrint(&ps); break;
    185. 		default:
    186. 			break;
    187. 		}
    188. 	} while (op != -1);
    189. 	
    190. 	SeqListDestroy(&ps);
    191. 	return 0;
    192. }

  • 相关阅读:
    ToBeWritten之基于ATT&CK的模拟攻击：闭环的防御与安全运营
    2022下半年各省软考报名费用汇总，不知道的看这里
    docker开机启动设置
    pytorch初学笔记（一）：如何加载数据和Dataset实战
    牛客——OR36 链表的回文结构（C语言，配图，快慢指针）
    只因写了一段爬虫，公司 200 多人被抓！
    AI 智能时代，如何快速搞懂向量数据库库？
    C++——虚函数、虚析构函数、纯虚函数、抽象类
    linux源码安装postgresql以及smlar插件
    REVERSE-COMPETITION-HWS-5TH-2022
  • 原文地址：https://blog.csdn.net/weixin_53269843/article/details/127717044