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

数据结构-顺序表（2）_seqlist.h

作者：酷酷是懒虫 | 2024-07-19 11:12:48

赞

踩

seqlist.h

目录

1. 线性表

2. 顺序表

2.1 动态顺序表

3. 接口实现

前期工作

3.1 初始化、销毁与检查容量

3.1.1 初始化

3.1.2 销毁

3.1.3 检查容量

3.2 尾插

3.3 尾删

3.4 头插

3.5 头删

3.6 插入

3.7 删除

顺序表源码

SeqList.h

SeqList.c

test.c

写在最后：

1. 线性表

线性表是n个具有相同特性的数据元素的有限序列，

常见的线性表：顺序表、链表、栈、队列、字符串等等。

2. 顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。

2.1 动态顺序表

我们一般使用的都是动态的顺序表。

3. 接口实现

前期工作

在VS上建三个工程文件，

test.c用来测试顺序表；

SeqList.c用来实现接口；

SeqList.h用来包头文件，和创建动态顺序表的基本结构；

头文件如下：

  1. #pragma once
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <assert.h>
  6.  
  7. #define INIT_CAPACITY 4
  8.  
  9. //选择需要的类型
  10. typedef int SLDatatype;
  11.  
  12. //动态的顺序表
  13. typedef struct SeqList
  14. {
  15. 	SLDatatype* a;
  16. 	int size;	  //有效的数据个数
  17. 	int capacity; //顺序表的空间容量
  18. }SL;
  19.  
  20. //顺序表的增删查改:
  21.  
  22. //初始化顺序表
  23. void SeqInit(SL* s);
  24.  
  25. //销毁顺序表
  26. void SeqDestory(SL* s);
  27.  
  28. //打印顺序表
  29. void SeqPrint(SL* s);
  30.  
  31. //检查容量
  32. void CheckCapacity(SL* s);
  33.  
  34. //尾插
  35. void SeqPushBack(SL* s, SLDatatype x);
  36.  
  37. //尾删
  38. void SeqPopBack(SL* s);
  39.  
  40. //头插
  41. void SeqPushFront(SL* s, SLDatatype x);
  42.  
  43. //头删
  44. void SeqPopFront(SL* s);
  45.  
  46. //插入
  47. void SeqInsert(SL* s, int pos, SLDatatype x);
  48.  
  49. //删除
  50. void SeqErase(SL* s, int pos);

3.1 初始化、销毁与检查容量

接口如下：

3.1.1 初始化

  1. //初始化顺序表
  2. void SeqInit(SL* ps)
  3. {
  4. 	//结构体指针不能为空
  5. 	assert(ps);
  6.  
  7. 	//开辟空间
  8. 	ps->a = (SLDatatype*)malloc(sizeof(SLDatatype) * INIT_CAPACITY);
  9.  
  10. 	//检查
  11. 	if (ps->a == NULL)
  12. 	{
  13. 		perror("malloc fail");
  14. 	}
  15. 	ps->size = 0;
  16. 	ps->capacity = INIT_CAPACITY;
  17. }

3.1.2 销毁

  1. //销毁顺序表
  2. void SeqDestory(SL* ps)
  3. {
  4. 	//结构体指针不能为空
  5. 	assert(ps);
  6.  
  7. 	//释放并置空
  8. 	free(ps->a);
  9. 	ps->a = NULL;
  10. 	ps->capacity = ps->size = 0;
  11. }

3.1.3 检查容量

  1. //检查容量
  2. void CheckCapacity(SL* ps)
  3. {
  4. 	//结构体指针不能为空
  5. 	assert(ps);
  6.  
  7. 	if (ps->size == ps->capacity)
  8. 	{
  9. 		//增容（两倍）
  10. 		SLDatatype* tmp = (SLDatatype*)realloc(ps->a, sizeof(SLDatatype) * ps->capacity * 2);
  11.  
  12. 		//检查是否增容成功
  13. 		if (tmp == NULL)
  14. 		{
  15. 			perror("realloc fail");
  16. 			return;
  17. 		}
  18. 		ps->a = tmp;
  19. 		ps->capacity *= 2;
  20. 	}
  21. }

3.2 尾插

  1. //尾插
  2. void SeqPushBack(SL* ps, SLDatatype x)
  3. {
  4. 	//代码复用
  5. 	SeqInsert(ps, ps->size, x);
  6.  
  7. 	/*单独实现
  8. 	
  9. 	//结构体指针不能为空
  10. 	assert(ps);
  12. 	//检查容量
  13. 	CheckCapacity(ps);
  15. 	//尾插
  16. 	ps->a[ps->size++] = x;
  17. 	*/
  18. }

3.3 尾删

  1. //尾删
  2. void SeqPopBack(SL* ps)
  3. {
  4. 	//代码复用
  5. 	SeqErase(ps, ps->size - 1);
  6.  
  7. 	/*单独实现
  8. 	
  9. 	//结构体指针不能为空
  10. 	assert(ps);
  12. 	//检查顺序表是否为空
  13. 	assert(ps->size);
  15. 	//尾删
  16. 	ps->size--;
  17. 	*/
  18. }

3.4 头插

  1. //头插
  2. void SeqPushFront(SL* ps, SLDatatype x)
  3. {
  4. 	//代码复用
  5. 	SeqInsert(ps, 0, x);
  6.  
  7. 	/*单独实现
  8. 	
  9. 	//结构体指针不能为空
  10. 	assert(ps);
  12. 	//检查容量
  13. 	CheckCapacity(ps);
  15. 	//把值往后挪
  16. 	int end = ps->size - 1;
  17. 	while (end >= 0)
  18. 	{
  19. 		ps->a[end + 1] = ps->a[end];
  20. 		end--;
  21. 	}
  23. 	//头插
  24. 	ps->a[0] = x;
  25. 	ps->size++;
  26. 	*/
  27. }

3.5 头删

  1. //头删
  2. void SeqPopFront(SL* ps)
  3. {
  4. 	//代码复用
  5. 	SeqErase(ps, 0);
  6.  
  7. 	/*单独实现
  9. 	//结构体指针不能为空
  10. 	assert(ps);
  12. 	//当顺序表为零时就不能删了
  13. 	assert(ps->size);
  15. 	//将数据往前覆盖
  16. 	int begin = 1;
  17. 	while (begin < ps->size)
  18. 	{
  19. 		ps->a[begin - 1] = ps->a[begin];
  20. 		begin++;
  21. 	}
  22. 	ps->size--;
  23. 	*/
  24. }

3.6 插入

  1. //插入
  2. void SeqInsert(SL* ps, int pos, SLDatatype x)
  3. {
  4. 	//结构体指针不能为空
  5. 	assert(ps);
  6.  
  7. 	//pos需要在有数据的区间
  8. 	assert(pos >= 0 && pos <= ps->size);
  9.  
  10. 	//检查容量
  11. 	CheckCapacity(ps);
  12.  
  13. 	//往后挪动数据
  14. 	int end = ps->size - 1;
  15. 	while (end >= pos)
  16. 	{
  17. 		ps->a[end + 1] = ps->a[end];
  18. 		end--;
  19. 	}
  20.  
  21. 	//插入数据
  22. 	ps->a[pos] = x;
  23. 	ps->size++;
  24. }

3.7 删除

  1. //删除
  2. void SeqErase(SL* ps, int pos)
  3. {
  4. 	//结构体指针不能为空
  5. 	assert(ps);
  6.  
  7. 	//pos需要在有数据的区间
  8. 	assert(pos >= 0 && pos < ps->size);
  9.  
  10. 	//挪动数据
  11. 	int begin = pos + 1;
  12. 	while (begin < ps->size)
  13. 	{
  14. 		ps->a[begin - 1] = ps->a[begin];
  15. 		begin++;
  16. 	}
  17. 	ps->size--;
  18. }

我们发现，

其实顺序表核心的功能就是插入和删除，

只要我们完成这两个接口，

其他的接口的实现都是大同小异。

顺序表源码

SeqList.h

  1. #pragma once
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <assert.h>
  6.  
  7. #define INIT_CAPACITY 4
  8.  
  9. //选择需要的类型
  10. typedef int SLDatatype;
  11.  
  12. //动态的顺序表
  13. typedef struct SeqList
  14. {
  15. 	SLDatatype* a;
  16. 	int size;	  //有效的数据个数
  17. 	int capacity; //顺序表的空间容量
  18. }SL;
  19.  
  20. //顺序表的增删查改:
  21.  
  22. //初始化顺序表
  23. void SeqInit(SL* s);
  24.  
  25. //销毁顺序表
  26. void SeqDestory(SL* s);
  27.  
  28. //打印顺序表
  29. void SeqPrint(SL* s);
  30.  
  31. //检查容量
  32. void CheckCapacity(SL* s);
  33.  
  34. //尾插
  35. void SeqPushBack(SL* s, SLDatatype x);
  36.  
  37. //尾删
  38. void SeqPopBack(SL* s);
  39.  
  40. //头插
  41. void SeqPushFront(SL* s, SLDatatype x);
  42.  
  43. //头删
  44. void SeqPopFront(SL* s);
  45.  
  46. //插入
  47. void SeqInsert(SL* s, int pos, SLDatatype x);
  48.  
  49. //删除
  50. void SeqErase(SL* s, int pos);

SeqList.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include "SeqList.h"
  4.  
  5. //初始化顺序表
  6. void SeqInit(SL* ps)
  7. {
  8. 	//结构体指针不能为空
  9. 	assert(ps);
  10.  
  11. 	//开辟空间
  12. 	ps->a = (SLDatatype*)malloc(sizeof(SLDatatype) * INIT_CAPACITY);
  13.  
  14. 	//检查
  15. 	if (ps->a == NULL)
  16. 	{
  17. 		perror("malloc fail");
  18. 	}
  19. 	ps->size = 0;
  20. 	ps->capacity = INIT_CAPACITY;
  21. }
  22.  
  23. //销毁顺序表
  24. void SeqDestory(SL* ps)
  25. {
  26. 	//结构体指针不能为空
  27. 	assert(ps);
  28.  
  29. 	//释放并置空
  30. 	free(ps->a);
  31. 	ps->a = NULL;
  32. 	ps->capacity = ps->size = 0;
  33. }
  34.  
  35. //打印
  36. void SeqPrint(SL* ps)
  37. {
  38. 	//结构体指针不能为空
  39. 	assert(ps);
  40.  
  41. 	//遍历打印
  42. 	for (int i = 0; i < ps->size; i++)
  43. 	{
  44. 		printf("%d ", ps->a[i]); 
  45. 	}
  46. 	printf("\n");
  47. }
  48.  
  49. //检查容量
  50. void CheckCapacity(SL* ps)
  51. {
  52. 	//结构体指针不能为空
  53. 	assert(ps);
  54.  
  55. 	if (ps->size == ps->capacity)
  56. 	{
  57. 		//增容（两倍）
  58. 		SLDatatype* tmp = (SLDatatype*)realloc(ps->a, sizeof(SLDatatype) * ps->capacity * 2);
  59.  
  60. 		//检查是否增容成功
  61. 		if (tmp == NULL)
  62. 		{
  63. 			perror("realloc fail");
  64. 			return;
  65. 		}
  66. 		ps->a = tmp;
  67. 		ps->capacity *= 2;
  68. 	}
  69. }
  70.  
  71. //尾插
  72. void SeqPushBack(SL* ps, SLDatatype x)
  73. {
  74. 	//代码复用
  75. 	SeqInsert(ps, ps->size, x);
  76.  
  77. 	/*单独实现
  78. 	
  79. 	//结构体指针不能为空
  80. 	assert(ps);
  82. 	//检查容量
  83. 	CheckCapacity(ps);
  85. 	//尾插
  86. 	ps->a[ps->size++] = x;
  87. 	*/
  88. }
  89.  
  90. //尾删
  91. void SeqPopBack(SL* ps)
  92. {
  93. 	//代码复用
  94. 	SeqErase(ps, ps->size - 1);
  95.  
  96. 	/*单独实现
  97. 	* 
  98. 	//结构体指针不能为空
  99. 	assert(ps);
  101. 	//检查顺序表是否为空
  102. 	assert(ps->size);
  104. 	//尾删
  105. 	ps->size--;
  106. 	*/
  107. }
  108.  
  109. //头插
  110. void SeqPushFront(SL* ps, SLDatatype x)
  111. {
  112. 	//代码复用
  113. 	SeqInsert(ps, 0, x);
  114.  
  115. 	/*单独实现
  116. 	
  117. 	//结构体指针不能为空
  118. 	assert(ps);
  120. 	//检查容量
  121. 	CheckCapacity(ps);
  123. 	//把值往后挪
  124. 	int end = ps->size - 1;
  125. 	while (end >= 0)
  126. 	{
  127. 		ps->a[end + 1] = ps->a[end];
  128. 		end--;
  129. 	}
  131. 	//头插
  132. 	ps->a[0] = x;
  133. 	ps->size++;
  134. 	*/
  135. }
  136.  
  137. //头删
  138. void SeqPopFront(SL* ps)
  139. {
  140. 	//代码复用
  141. 	SeqErase(ps, 0);
  142.  
  143. 	/*单独实现
  145. 	//结构体指针不能为空
  146. 	assert(ps);
  148. 	//当顺序表为零时就不能删了
  149. 	assert(ps->size);
  151. 	//将数据往前覆盖
  152. 	int begin = 1;
  153. 	while (begin < ps->size)
  154. 	{
  155. 		ps->a[begin - 1] = ps->a[begin];
  156. 		begin++;
  157. 	}
  158. 	ps->size--;
  159. 	*/
  160. }
  161.  
  162. //插入
  163. void SeqInsert(SL* ps, int pos, SLDatatype x)
  164. {
  165. 	//结构体指针不能为空
  166. 	assert(ps);
  167.  
  168. 	//pos需要在有数据的区间
  169. 	assert(pos >= 0 && pos <= ps->size);
  170.  
  171. 	//检查容量
  172. 	CheckCapacity(ps);
  173.  
  174. 	//往后挪动数据
  175. 	int end = ps->size - 1;
  176. 	while (end >= pos)
  177. 	{
  178. 		ps->a[end + 1] = ps->a[end];
  179. 		end--;
  180. 	}
  181.  
  182. 	//插入数据
  183. 	ps->a[pos] = x;
  184. 	ps->size++;
  185. }
  186.  
  187. //删除
  188. void SeqErase(SL* ps, int pos)
  189. {
  190. 	//结构体指针不能为空
  191. 	assert(ps);
  192.  
  193. 	//pos需要在有数据的区间
  194. 	assert(pos >= 0 && pos < ps->size);
  195.  
  196. 	//挪动数据
  197. 	int begin = pos + 1;
  198. 	while (begin < ps->size)
  199. 	{
  200. 		ps->a[begin - 1] = ps->a[begin];
  201. 		begin++;
  202. 	}
  203. 	ps->size--;
  204. }

test.c

  1. #define _CRT_SECURE_NO_WARNINGS 1
  2.  
  3. #include "SeqList.h"
  4.  
  5. //测试接口
  6. void SLTest()
  7. {
  8. 	SL s;
  9. 	SeqInit(&s);
  10.  
  11. 	SeqPushBack(&s, 1);
  12. 	SeqPushBack(&s, 2);
  13. 	SeqPushBack(&s, 3);
  14. 	SeqPushBack(&s, 4);
  15. 	SeqPushBack(&s, 5);
  16. 	SeqPushBack(&s, 6);
  17. 	
  18. 	SeqPrint(&s);
  19.  
  20. 	SeqPopBack(&s);
  21. 	SeqPopBack(&s);
  22.  
  23. 	SeqPrint(&s);
  24.  
  25. 	SeqPushFront(&s, 10);
  26. 	SeqPushFront(&s, 50);
  27.  
  28. 	SeqPrint(&s);
  29.  
  30. 	SeqPopFront(&s);
  31. 	SeqPopFront(&s);
  32. 	SeqPopFront(&s);
  33.  
  34. 	SeqPrint(&s);
  35.  
  36. 	SeqDestory(&s);
  37. }
  38.  
  39. int main()
  40. {
  41. 	SLTest();
  42. 	return 0;
  43. }

测试结果无误。

写在最后：

以上就是本篇文章的内容了，感谢你的阅读。

如果喜欢本文的话，欢迎点赞和评论，写下你的见解。

如果想和我一起学习编程，不妨点个关注，我们一起学习，一同成长。

之后我还会输出更多高质量内容，欢迎收看。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

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

  

闽ICP备14008679号