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

顺序表和链表【数据结构】【基于C语言实现】【一站式速通】

作者：从前慢现在也慢 | 2024-02-15 23:57:54

赞

踩

顺序表和链表【数据结构】【基于C语言实现】【一站式速通】

目录

顺序表

顺序表的优点

顺序表的实现

1.结构体的定义

2.初始化数组

 3.插入数据

4.其余接口函数的实现

5.释放内存

顺序表的缺陷

单向链表

单向链表的优点

单向链表的实现

1.链表的定义 

2.链表的初始化

3.其余接口函数的实现

5.释放内存

单向链表的缺陷

双向链表

双向链表的优点

双向链表的实现

1.双向链表的初始化

2.链表的初始化

3.其余接口函数的实现

 4.释放内存

 双向链表的缺陷

总结

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使

用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...

线性表和链表的物理结构：

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，

线性表在物理上存储时，通常以数组和链式结构的形式存储。画出它们的物理结构只是为了方便我们理解它们各自的特性。

顺序表

在计算机科学中，顺序表是一种常见且重要的数据结构。顾名思义，顺序表是一种按照元素在内存中的物理顺序进行存储和访问的数据结构。它可以看作是一段连续的内存空间，用于存储相同类型的元素。 

顺序表的优点

1.支持随机访问：由于顺序表在内存中是连续存储的，因此可以通过下标直接访问任何一个元素。这使得顺序表具有高效的随机访问能力，时间复杂度为O(1)。

2.有序存储：顺序表中的元素按照其在数组中的位置顺序存储，因此保持了元素的逻辑顺序。这使得顺序表适用于需要保持元素有序性的场景，例如排序、查找等操作。

3.内存紧凑：顺序表中的元素在内存中是连续存储的，不需要额外的指针来连接各个元素，因此可以更好地利用内存空间。这使得顺序表相对于链表等动态数据结构来说，具有更小的存储空间和更高的存取效率。

顺序表的实现

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

顺序表一般都是靠数组来进行存储，如果在栈上开辟一块空间，我们需要指定数组的元素个数，如果指定个数过少，我们的数据没有办法进行存储；如果指定个数过多，又会造成资源的浪费。所以，我们选择在堆上开辟空间，这样我们可以实现一个动态存储的数据表，按需分配空间。下面我们来着手实现一个顺序表：

1.结构体的定义

因为要实现一个动态增长的版本，所以我们要给定一个数组的指针，一个记录有效数据个数的变量，和一个代表数组容量的变量，用以在我们空间不足时候进行扩容操作。

  1. //实现一个顺序表
  2. typedef struct Sequence
  3. {
  4. 	Seqtype* a;
  5. 	int size;
  6. 	int capacity;
  7. }SeqList;

2.初始化数组

这里要传的是结构体的指针，因为我们需要改变结构体里面的值，需要传址调用

当我们只定义而不进行初始化的时候，我们的指针会是野指针，size和capacity都会是随机数，因此我们要进行一下初始化

  1. void SeqListInit(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	ps->a = NULL;
  5. 	ps->capacity = ps->size = 0;
  6. }

 3.插入数据

当插入数据的时候，我们就要考虑空间够不够的问题了，经过思考其实可以发现,size是有效数据的个数,capacity是容量，当有效数据的个数刚好等于容量的时候其实就是要扩容的时候。刚开始时，我们还没有分配空间，所以我们先给定容量为4，后期空间不足再调整即可

  1. void SeqListPushBack(SeqList* ps, Seqtype x)
  2. {
  3. 	assert(ps);
  4. 	if (ps->size == ps->capacity)
  5. 	{
  6. 		//扩容---三目操作符
  7. 		int newcapacity = ps->capacity > 0 ? ps->capacity * 2 : 4;
  8. 		Seqtype* newsapce = (Seqtype*)realloc(ps->a ,sizeof(Seqtype) * newcapacity);
  9. 		if (newsapce == NULL)                                                      
  10. 		{
  11. 			printf("malloc fail\n");
  12. 			exit(-1);
  13. 		}
  14. 		ps->a = newsapce;
  15. 		ps->capacity = newcapacity;
  16. 	}
  17. 	ps->a[ps->size++] = x;
  18. }

注意：在分配空间时，我们一定要使用realloc，而不是malloc。当使用realloc时，如果给定一个空指针，那他此时就是malloc的功能。realloc与malloc的一个重要的区别就是：realloc在堆上申请空间的时候，会返回申请到的空间的指针，并把原先的内容按字节拷贝到该指针指向的数组中，而malloc不会拷贝，切记切记！！！

4.其余接口函数的实现

  1. //接口函数
  2. void SeqListPrint(SeqList* ps);
  3. void SeqListInit(SeqList* ps);
  4. void SeqListPushBack(SeqList* ps, Seqtype x);
  5. void SeqListPushFront(SeqList* ps, Seqtype x);
  6. void SeqListPopBack(SeqList* ps);
  7. void SeqListDestroy(SeqList* ps);
  8. void SeqListPopFront(SeqList* ps);
  9. int SeqListFind(SeqList* ps, Seqtype x);
  10. void SeqListInsert(SeqList* ps, Seqtype x, int pos);
  11. void SeqListCheckCapacity(SeqList* ps);

这里的接口函数太多，不再一一赘述，只把几个接口函数的思想进行分析

  1. void SeqListPrint(SeqList* ps)
  2. {
  3. 	for (int i = 0; i < ps->size; i++)
  4. 	{
  5. 		printf("%d ", ps->a[i]);
  6. 	}
  7. 	printf("\n");
  8. }
  9.  
  10. void SeqListCheckCapacity(SeqList* ps)
  11. {
  12. 	if (ps->size == ps->capacity)
  13. 	{
  14. 		//扩容
  15. 		int newcapacity = ps->capacity > 0 ? ps->capacity * 2 : 4;
  16. 		Seqtype* newsapce = (Seqtype*)realloc(ps->a, sizeof(Seqtype) * newcapacity);
  17. 		if (newsapce == NULL)                                                       
  18. 		{
  19. 			printf("malloc fail\n");
  20. 			exit(-1);
  21. 		}
  22. 		ps->a = newsapce;
  23. 		ps->capacity = newcapacity;
  24. 	}
  25. }
  26.  
  27. void SeqListPopBack(SeqList* ps)
  28. {
  29. 	assert(ps);
  30. 	assert(ps->size > 0);
  31. 	ps->size--;
  32. }
  33.  
  34. void SeqListPushFront(SeqList* ps, Seqtype x)
  35. {
  36. 	assert(ps);
  37. 	SeqListCheckCapacity(ps);
  38. 	int end = ps->size - 1;
  39. 	while (end >= 0)
  40. 	{
  41. 		ps->a[end+1] = ps->a[end];
  42. 		end--;
  43. 	}
  44. 	ps->a[0] = x;
  45. 	ps->size++;
  46. }
  47.  
  48. void SeqListPopFront(SeqList* ps)
  49. {
  50. 	assert(ps);
  51. 	assert(ps->size > 0);
  52. 	int begin = 1;
  53. 	while (begin < ps->size)
  54. 	{
  55. 		ps->a[begin -1] = ps->a[begin];
  56. 		begin++;
  57. 	}
  58. 	ps->size--;
  59. }
  60.  
  61. int SeqListFind(SeqList* ps, Seqtype x)
  62. {
  63. 	assert(ps);
  64. 	//遍历数组
  65. 	int i = 0;
  66. 	for ( i = 0; i < ps->size; i++)
  67. 	{
  68. 		if (ps->a[i] == x)
  69. 		{
  70. 			break;
  71. 		}
  72. 	}
  73. 	return i;
  74. }
  75.  
  76. void SeqListInsert(SeqList* ps, Seqtype x, int pos)
  77. {
  78. 	assert(ps);
  79. 	assert(pos < ps->size);
  80. 	SeqListCheckCapacity(ps);
  81.  
  82. 	int end = ps->size - 1;
  83. 	while (end >= pos)
  84. 	{
  85. 		ps->a[end + 1] = ps->a[end];
  86. 		end--;
  87. 	}
  88. 	ps->a[pos] = x;
  89. 	ps->size++;
  90. }

我们发现在插入数据的时候，不管是头插还是为尾插，只要是插入数据，都需要进行判断空间是否充足的处理，因此我们决定把这个检查空间的功能封装成一个函数，方便我们后续的调用，这里其实就是代码复用。

  1. void SeqListCheckCapacity(SeqList* ps)
  2. {
  3. 	if (ps->size == ps->capacity)
  4. 	{
  5. 		//扩容
  6. 		int newcapacity = ps->capacity > 0 ? ps->capacity * 2 : 4;
  7. 		Seqtype* newsapce = (Seqtype*)realloc(ps->a, sizeof(Seqtype) * newcapacity);
  8. 		if (newsapce == NULL)                                                       
  9. 		{
  10. 			printf("malloc fail\n");
  11. 			exit(-1);
  12. 		}
  13. 		ps->a = newsapce;
  14. 		ps->capacity = newcapacity;
  15. 	}
  16. }

其实，在实现完Insert函数和Erase函数之后，我们就会发现，头删尾删都可以进行代码复用了，我们的代码能够得到极大的简化。大家可以试着实现一下。

5.释放内存

因为我们的数组是开辟在堆上面的，所以我们需要在使用完之后释放掉这块内存，否则就会造成内存泄漏。

  1. void SeqListDestroy(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	free(ps->a);
  5. 	ps->a = NULL;
  6. 	ps->capacity = ps->size = 0;
  7. }

顺序表的缺陷

1.空间不够了，需要扩容，扩容是有消耗的，会产生很多内存碎片。

2.头部/中间位置的插入删除，需要挪动数据，时间复杂度为O(N)，挪动数据也是有消耗的

3.为避免重复扩容，一次一般都是按倍数去扩容（一般是二倍），还可能存在一定的空间浪费

4.增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。

单向链表

 针对顺序表的缺陷，设计出了链表。按需申请空间，不用了就释放空间（更加合理的使用了空间）

头部中间插入删除数据，不需要挪动数据。

链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

单向链表的优点

因为链表是根据顺序表的缺陷进行设计的，所以链表的优势就在于，它里面的数据不是连续存储的，而是通过一个个的指针链接起来的。因此不存在会浪费空间，造成空间碎片的问题。

1.动态性：链表的大小可以动态地进行调整，不需要事先预留固定的内存空间。在插入或删除节点时，只需要调整指针的指向，而不需要移动其他节点。这使得链表适用于频繁进行插入和删除操作的场景。

2.灵活性：相比于顺序表，链表的结构更加灵活。链表可以根据实际需求设计成单向链表、双向链表或循环链表。单向链表只有一个指针指向下一个节点，双向链表则同时具有前向和后向指针，而循环链表的尾节点指针指向头节点。根据实际需求，我们可以选择合适的链表类型。

3.内存利用率高：链表在内存中不要求连续存储，因此可以更好地利用内存空间。相比于顺序表，链表可以动态地分配内存，并且不会产生内存碎片的问题。

单向链表的实现

1.链表的定义 

我们可以根据链表的物理结构来设计链表，我们首先要定义一个变量来存储数据，因为我们还要存储下一个数据的地址，所以我们还要定义一个指针。

  1. typedef struct Slist
  2. {
  3. 	SLtype data;
  4. 	struct Slist* next;
  5. }SLTnode;

2.链表的初始化

因为我们不直接把所需空间直接全部初始化完成，而是一个一个地存储，通过该结构体中指向下一个数据的指针找到下一个数据，所以链表的初始化就是先创建一个新节点，并让其中的指针指向空，防止野指针。

  1. SLTnode* CreatListNode(SLtype x)
  2. {
  3. 	//创建一个新的节点
  4. 	SLTnode* newnode = malloc(sizeof(SLtype));
  5. 	if (newnode == NULL)
  6. 	{
  7. 		printf("malloc fail\n");
  8. 		exit(-1);
  9. 	}
  10. 	newnode->data = x;
  11. 	newnode->next = NULL;
  12. 	return newnode;
  13. }

3.插入数据

插入数据时我们写的是二级指针，有些人可能不理解。在此进行说明：

为什么要传二级指针？

类比int类型的数据，我们在传址调用的时候,&该变量，我们在函数中用的是(int *)指针进行接受。我们如果要传址调用(int *)类型的变量，就要用二级指针(int **)来进行接收。

  1. void SLTpushback(SLTnode** pphead, SLtype x)
  2. {
  3. 	SLTnode* newnode = CreatListNode(x);
  4. 	if (*pphead == NULL)
  5. 	{
  6. 		*pphead = newnode;
  7. 	}
  8. 	else
  9. 	{
  10. 		//找到尾节点
  11. 		SLTnode* tail = *pphead;
  12. 		while (tail->next != NULL)
  13. 		{
  14. 			tail = tail->next;
  15. 		}
  16. 		//链接
  17. 		tail->next = newnode;
  18. 	}
  19. }

3.其余接口函数的实现

  1. void SLTprint(SLTnode* phead);
  2. void SLTpushback(SLTnode** phead, SLtype x);
  3. void SLTpushfront(SLTnode** phead, SLtype x);
  4. void SLTpopback(SLTnode** phead);
  5. void SLTpopfront(SLTnode** phead);
  6. SLTnode* SLTfind(SLTnode* phead, SLtype x);
  7. void SLTinsert(SLTnode** phead, SLTnode* pos , SLtype x);
  8. void SLTDestory(SLTnode** phead);

 其余接口函数的实现不再一一赘述，只挑选重点部分进行说明

  1. void SLTprint(SLTnode* phead)
  2. {
  3. 	SLTnode* cur = phead;
  4. 	while (cur != NULL)
  5. 	{
  6. 		printf("%d->", cur->data);
  7. 		cur = cur->next;
  8. 	}
  9. 	printf("NULL\n");
  10. }
  11.  
  12. void SLTpushback(SLTnode** pphead, SLtype x)
  13. {
  14. 	SLTnode* newnode = CreatListNode(x);
  15. 	if (*pphead == NULL)
  16. 	{
  17. 		*pphead = newnode;
  18. 	}
  19. 	else
  20. 	{
  21. 		//找到尾节点
  22. 		SLTnode* tail = *pphead;
  23. 		while (tail->next != NULL)
  24. 		{
  25. 			tail = tail->next;
  26. 		}
  27. 		//链接
  28. 		tail->next = newnode;
  29. 	}
  30. 	
  31. }
  32.  
  33. void SLTpushfront(SLTnode** pphead, SLtype x)
  34. {
  35. 	SLTnode* newnode = CreatListNode(x);
  36. 	newnode->next = *pphead;
  37. 	*pphead = newnode;
  38. }
  39.  
  40. void SLTpopback(SLTnode** pphead)
  41. {
  42. 	assert(*pphead != NULL);
  43. 	if ((*pphead)->next == NULL)
  44. 	{
  45. 		free(*pphead);
  46. 		*pphead = NULL;
  47. 	}
  48. 	else
  49. 	{
  50. 		SLTnode* tail = *pphead;
  51. 		SLTnode* previous = *pphead;
  52. 		while (tail->next)
  53. 		{
  54. 			previous = tail;
  55. 			tail = tail->next;
  56. 		}
  57. 		free(tail);
  58. 		tail = NULL;
  59. 		previous->next = NULL;//注意：previous是一个指针，指向的是尾节点的前一个节点的地址，
  60. 		                      //我们的目的是要把该内存块中指向下一内存的地址给置空
  61. 	}
  62. 	//错误方法
  63. 	/*SLTnode* tail = *pphead;
  64. 	while (tail->next)
  65. 	{
  66. 		tail = tail->next;
  67. 	}
  68. 	free(tail);
  69. 	tail = NULL;*/   //这种方式没办法使新链表指向原最后一个数据的指针置空，造成野指针
  70. }
  71.  
  72. void SLTpopfront(SLTnode** pphead)
  73. {
  74. 	assert(*pphead != NULL);
  75. 	SLTnode* next = (*pphead)->next;
  76. 	free(*pphead);
  77. 	*pphead = NULL;
  78. }
  79. SLTnode* SLTfind(SLTnode* phead, SLtype x)
  80. {
  81. 	assert(phead != NULL);
  82. 	//遍历链表，找到要查找的值
  83. 	SLTnode* tail = phead;
  84. 	while (tail->next)
  85. 	{
  86. 		if (tail->data == x)
  87. 		{
  88. 			return tail;
  89. 		}
  90. 		tail = tail->next;
  91. 	}
  92. 	return NULL;
  93. }
  94.  
  95. void SLTinsert(SLTnode** phead, SLTnode* pos, SLtype x)
  96. {
  97. 	assert(*phead != NULL);
  98. 	SLTnode* newnode = CreatListNode( x );
  99. 	if (*phead == pos)
  100. 	{
  101. 		SLTpushfront(phead , x);
  102. 	}
  103. 	else
  104. 	{
  105. 		SLTnode* previous = *phead;
  106. 		while (previous->next != pos)
  107. 		{
  108. 			previous = previous->next;
  109. 		}
  110. 		previous->next = newnode;
  111. 		newnode->next = pos;
  112. 	}
  113. }

我们在删除尾部的数据时，不能只把最后一个数据的空间free掉，还要把它的前一个数据中指向该数据的指针给置成NULL，而在单向链表中，我们可以轻松取得链表的头和尾，但是如果要访问倒数第二个值，还需要额外的指针，这也是单向链表的一个弊端！

5.释放内存

链表的节点是malloc出来的，为了防止内存泄漏，我们在使用完之后，要进行内存释放。

链表的内存释放有点特殊，因为它们不是连续存放的，开辟了多个节点，每个节点都保留着指向下一个节点的指针，所以我们要把这些节点全部free掉。

  1. //销毁链表
  2. void SLTDestory(SLTnode** phead)
  3. {
  4. 	SLTnode* cur = *phead;
  5. 	while (cur != NULL)
  6. 	{
  7. 		SLTnode* next = cur->next;
  8. 		free(cur);
  9. 		cur = next;
  10. 	}
  11. 	*phead = NULL;
  12. }

单向链表的缺陷

1.不支持随机访问：在删除数据时，我们发现了，每一个数据，都要存一个指针去链接后面的数据节点，不支持随机访问（用下标直接访问第i个）【顺序表支持】

2.删除节点需谨慎：删除链表中的某个节点时，需要修改前一个节点的指针，将其指向下一个节点，然后释放被删除节点的内存。如果不仔细处理指针的更新，可能会导致内存泄漏或者链表断裂。

双向链表

双向链表的优点

 双向链表的设计可以看做是单向链表的扩展，每个节点除了存储数据外，还需要存储前继节点和后继节点的指针。这种设计使得双向链表具有以下优点：

1.可以双向遍历：由于每个节点都有前继节点和后继节点的指针，因此可以从任意一个节点开始，顺着前继节点或后继节点进行遍历。这使得双向链表在某些场景下具有比单向链表更高的遍历效率。

2.方便进行插入和删除操作：在双向链表中插入或删除节点时，只需要修改相邻节点的指针即可，不需要像单向链表那样找到前一个节点来修改指针。这使得双向链表在插入和删除操作方面更加方便。

双向链表的实现

1.双向链表的初始化

双向链表基于单向链表，只不过是又加入了一个指针，我们注意命名规范，直接定义即可。

  1. typedef struct ListNode
  2. {
  3. 	DLtype data;
  4. 	struct ListNode* prev;
  5. 	struct ListNode* next;
  6. }DL;

2.链表的初始化

 初始化时需要注意的是，当链表中只有一个数据的时候，这时候的两个指针都指向自己。

  1. DL* ListInit(DL* phead)
  2. {
  3. 	DL* newnode = (DL*)malloc(sizeof(DL));
  4. 	if (newnode == NULL)
  5. 	{
  6. 		printf("malloc fail\n");
  7. 		exit(-1);
  8. 	}
  9. 	newnode->prev = newnode;
  10. 	newnode->next = newnode;
  11. 	return newnode;
  12. }

3.其余接口函数的实现

  1. DL* ListInit(DL* phead);
  2. void Listprint(DL* phead);
  3. void Listpushfront(DL* phead, DLtype x);
  4. void Listpushback(DL* phead, DLtype x);
  5. void Listpopfront(DL* phead);
  6. void Listpopback(DL* phead);
  7. void ListInsert(DL* pos,DLtype x);
  8. void Listpop(DL* pos);
  9. void Listfind(DL* phead);

这里跟单向链表的逻辑其实相差不多，只是过程比较繁琐，在这里我就挑选其中的几个进行实现 

  1. void Listprint(DL* phead)
  2. {
  3. 	assert(phead);
  4. 	DL* cur = phead->next;
  5. 	while (cur != phead)
  6. 	{
  7. 		printf("%d ", cur->data);
  8. 		cur = cur->next;
  9. 	}
  10. 	printf("\n");
  11. }
  12.  
  13. void Listpushfront(DL* phead, DLtype x)
  14. {
  15. 	ListInsert(phead->next, x);
  16. }
  17.  
  18. void Listpushback(DL* phead, DLtype x)
  19. {
  20. 	ListInsert(phead, x);
  21. }
  22.  
  23. void ListInsert(DL* pos, DLtype x)
  24. {
  25. 	DL* newnode = (DL*)malloc(sizeof(DL));
  26. 	if (newnode == NULL)
  27. 	{
  28. 		printf("malloc fail\n");
  29. 		exit(-1);
  30. 	}
  31. 	newnode->data = x;
  32.  
  33. 	DL* prev = pos->prev;
  34. 	if (prev == NULL) // 如果pos是头节点
  35. 	{
  36. 		newnode->next = pos;
  37. 		pos->prev = newnode;
  38. 	}
  39. 	else // 正常情况
  40. 	{
  41. 		prev->next = newnode;
  42. 		newnode->prev = prev;
  43. 		newnode->next = pos;
  44. 		pos->prev = newnode;
  45. 	}
  46. }

 4.释放内存

我们在释放current的内存之前保存下一个空间的地址，然后cur一直往后面走，free掉经过的空间，当cur指向NULL的时候，所有的空间都被free完了 

  1. void ListFree(DL** phead)
  2. {
  3.     DL* current = phead;
  4.  
  5.     while (current != NULL)
  6.     {
  7.         DL* next = current->next;
  8.         free(current);
  9.         current = next;
  10.     }
  11.    *phead = NULL;
  12. }

 双向链表的缺陷

1.需要更多的存储空间：相比于单向链表，双向链表需要多存储一个指针，因此需要更多的存储空间。这对于需要大量使用链表的应用程序来说可能会成为内存限制的瓶颈。

2.实现较为繁琐：相比于单向链表，双向链表需要同时操作两个指针，很容易把人绕晕。

总结

通过上面的分析，我们发现不管是线性表还是单向链表，甚至是双向链表，都有自己的优缺点，我们要根据实际的使用场景来选择要使用哪一种方式来进行存储数据，快捷、高效地处理问题。

今天的分享到这里就结束了，欢迎讨论交流~

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

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

  

闽ICP备14008679号