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

『初阶数据结构 • C语言』⑧ - 动态顺序表详解（附完整源码）_c语言的动态顺序表

作者：我家小花儿 | 2024-04-23 15:29:22

赞

踩

c语言的动态顺序表

本章内容

写在前面

1.静态与动态是指什么？

2.动态顺序表结构的定义

3.动态顺序表的函数接口实现

4.动态顺序表的问题及思考

5.关于顺序表的OJ题

6.OJ答案及解析

1.移除元素

2.删除有序数组中的重复项

​3.合并两个有序数组

7.动态顺序表完整源码

1.SeqList.h

2.SeqList.c

 

 

写在前面

上一章我们学习了静态顺序表的增删查改，并认识了静态顺序表的存储结构与静态顺序表的在不同场景下的优劣。静态顺序表与动态顺序表都叫做顺序表，只不过我们平时口头所提的顺序表指的是动态顺序表。静态顺序表的局限性太高，无法应对各种复杂的情况所以我们几乎不用它。本章我们就来学习动态顺序表的实现。

1.静态与动态是指什么？

静态顺序表：顺序表的大小固定，存储的数据个数有限。

  1. #define N 5
  2. typedef int SLDataType;
  3.  
  4. //静态顺序表
  5. typedef struct SeqList
  6. {
  7. 	SLDataType a[N];//定长数组
  8. 	int size;//记录存储多少个有效数据
  9. }SeqList;

动态顺序表：运用动态内存管理，可按需调整顺序表的大小。

  1. typedef int SLDataType;
  2.  
  3. //动态顺序表
  4. typedef struct SeqList
  5. {
  6. 	SLDataType* a;
  7. 	int size;//记录有多少个有效数据
  8. 	int capacity;//记录顺序表的容量大小
  9. }SeqList;

2.动态顺序表结构的定义

  1. typedef int SLDataType;
  2.  
  3. //动态顺序表
  4. typedef struct SeqList
  5. {
  6. 	SLDataType* a;
  7. 	int size;//记录有多少个有效数据
  8. 	int capacity;//记录顺序表的容量大小
  9. }SeqList;

3.动态顺序表的函数接口实现

  1. //初始化顺序表
  2. void SLInit(SeqList* ps);
  3. //释放空间
  4. void SLDestroy(SeqList* ps);
  5. //检查顺序表是否已满
  6. void CheakCapacity(SeqList* ps);
  7. //动态顺序表的尾插
  8. void SLPushBack(SeqList* ps, SLDataType data);
  9. //动态顺序表的尾删
  10. void SLPopBack(SeqList* ps);
  11. //动态顺序表的头插
  12. void SLPushFront(SeqList* ps, SLDataType data);
  13. //动态顺序表的头删
  14. void SLPopFront(SeqList* ps);
  15. //pos位置插入数据
  16. void SLInsert(SeqList* ps, int pos, SLDataType data);
  17. //pos位置删除数据
  18. void SLErase(SeqList* ps, int pos);
  19. //查找数据
  20. int SLFind(SeqList* ps, SLDataType data, int begin);
  21. //判断数组是否已满
  22. bool IsFull(SeqList* ps);
  23. //打印存储的数据
  24. void SLPrint(SeqList* ps);

以下是各个接口的实现：

  1. void SLInit(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	ps->a = NULL;
  5. 	ps->size = 0;
  6. 	ps->capacity = 0;
  7. }
  1. void SLDestroy(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	//若ps->a不为NULL，则释放空间
  5. 	if (ps->a)
  6. 	{
  7. 		free(ps->a);
  8. 		ps->a = NULL;
  9. 		ps->capacity = ps->size = 0;
  10. 	}
  11. }
  1. void CheakCapacity(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	if (ps->capacity == ps->size)
  5. 	{
  6. 		//若是第一次扩容，则大小为4；
  7. 		//若不是第一次，则每次扩容为之前容量的2倍
  8. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  9. 		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
  10. 		if (tmp == NULL)
  11. 		{
  12. 			perror("malloc fail");
  13. 			exit(-1);
  14. 		}
  15. 		ps->a = tmp;
  16. 		ps->capacity = newCapacity;
  17. 	}
  18. 	//检查是否做到扩容
  19. 	printf("扩容成功,现在的容量为:%d\n", ps->capacity);
  20. }
  1. void SLPushBack(SeqList* ps, SLDataType data)
  2. {
  3. 	assert(ps);
  4. 	CheakCapacity(ps);
  5. 	//插入数据
  6. 	ps->a[ps->size] = data;
  7. 	ps->size++;
  8. }
  1. void SLPopBack(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	ps->size--;
  5. }
  1. void SLPushFront(SeqList* ps, SLDataType data)
  2. {
  3. 	assert(ps);
  4. 	CheakCapacity(ps);
  5. 	//挪动数据
  6. 	for (int i = ps->size - 1; i >= 0; i--)
  7. 	{
  8. 		ps->a[i + 1] = ps->a[i];
  9. 	}
  10. 	//插入数据
  11. 	ps->a[0] = data;
  12. 	ps->size++;
  13. }
  1. void SLPopFront(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	assert(ps->size > 0);
  5. 	//挪动数据
  6. 	for (int i = 0; i < ps->size - 1; i++)
  7. 	{
  8. 		ps->a[i] = ps->a[i + 1];
  9. 	}
  10. 	ps->size--;
  11. }
  1. void SLInsert(SeqList* ps, int pos, SLDataType data)
  2. {
  3. 	assert(ps);
  4. 	CheakCapacity(ps);
  5. 	//挪动数据
  6. 	for (int i = ps->size - 1; i >= pos; i--)
  7. 	{
  8. 		ps->a[i + 1] = ps->a[i];
  9. 	}
  10. 	//插入数据
  11. 	ps->a[pos] = data;
  12. 	ps->size++;
  13. }
  1. void SLErase(SeqList* ps, int pos)
  2. {
  3. 	assert(ps);
  4. 	assert(ps->size > 0);
  5. 	//挪动数据
  6. 	for (int i = pos; i < ps->size - 1; i++)
  7. 	{
  8. 		ps->a[i] = ps->a[i + 1];
  9. 	}
  10. 	ps->size--;
  11. }
  1. int SLFind(SeqList* ps, SLDataType data, int begin)
  2. {
  3. 	assert(ps);
  4. 	assert(begin < ps->size);
  5. 	for (int i = begin; i < ps->size; i++)
  6. 	{
  7. 		if (ps->a[i] == data)
  8. 		{
  9. 			return i;
  10. 		}
  11. 	}
  12. 	return -1;
  13. }
  1. void SLPrint(SeqList* ps)
  2. {
  3. 	assert(ps);
  4. 	for (int i = 0; i < ps->size; i++)
  5. 	{
  6. 		printf("%d ", ps->a[i]);
  7. 	}
  8. 	printf("\n");
  9. }

4.动态顺序表的问题及思考

动态顺序表与静态顺序表的差别仅仅在与一个容量是固定的，一个可以按需扩容。

动态顺序表看似灵活性有所提高但仍存在着空间浪费，特别是扩容次数越多，越容易造成空间浪费。那么有没有其他的数据结构可以解决这个问题呢？答案是肯定的。这个神奇的数据结构叫做链表，它是一种基于节点的数据结构。下一章我们就会见到它。

动态顺序表和静态顺序表都称为顺序表，它们的性能是相同的。关于顺序表的性能优劣我已经在上一章介绍过了，点击小卡片即可跳转。

静态顺序表详解http://t.csdn.cn/zwU7I

5.关于顺序表的OJ题

1.移除元素

原地移除数组中所有的元素val，要求时间复杂度为O(N)，空间复杂度为O(1)。 

移除元素https://leetcode.cn/problems/remove-element/

2.删除有序数组中的重复项

删除有序数组中的重复项https://leetcode.cn/problems/remove-duplicates-from-sorted-array/

3.合并两个有序数组

合并两个有序数组https://leetcode.cn/problems/merge-sorted-array/

6.OJ答案及解析

1.移除元素

题目要求不能开辟新的数组，所以我们的做法是遇到等于val的元素时，将数组末尾的元素依次倒着覆盖掉等于val的元素。

代码实现;

  1. int removeElement(int* nums, int numsSize, int val){
  2.     int i=0;
  3.     while(i<numsSize)
  4.     {
  5.         while(val==nums[i]&&i<numsSize)
  6.         {
  7.            nums[i]=nums[numsSize-1];
  8.            numsSize--;
  9.         }
  10.         i++;
  11.     }
  12.     return numsSize;
  13.  
  14. }

以数组nums={3,2,5,6,3,5},val=3为例。

第一步，检查索引为0处的值是否等于val；

 第二步，将索引为5处的值拷贝到索引为0处；

 第三步，检查索引为1处的值；

第四步，检查索引为2处的值；

 第五步，检查索引为3处的值；

 第六步，检查索引为4处的值；

 第七步，将索引为4处的值拷贝到索引为4处；

此时i已经大于numsSize，循环结束。 

2.删除有序数组中的重复项

本题我采用的是双指针的方式，p1来记录当前位置，p2来寻找与p1处的值不相同的元素。

代码实现：

  1. int removeDuplicates(int* nums, int numsSize){
  2.     int* p1=nums;
  3.     int* p2=nums+1;
  4.     int i=0;
  5.     int returnSize=1;//至少有一个元素
  6.     for(i=0;i<numsSize-1;i++)
  7.     {
  8.         if(*p1!=*(p2+i))
  9.         {
  10.             *(++p1)=*(p2+i);
  11.             returnSize++;
  12.         }
  13.     }
  14.     return returnSize;
  15. }

以数组nums={0,0,1,1,1,2,2,3,3,4}为例。

3.合并两个有序数组

这道题目我采用的是双指针的方式。p1指向nums1，p2指向nums2。另外需要额外开辟一个数组arr，当合并完成之后再将arr里的内容拷贝到nums1中。

代码实现：

  1. void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
  2.     int i=0;
  3.     int j=0;
  4.     int arr[200]={0};
  5.     int* p1=nums1;
  6.     int* p2=nums2;
  7.     int k=0;//记录arr数组里元素的个数
  8.     //检查数组是否为空
  9.     if(nums2Size==0)
  10.         return;
  11.     //将nums1或nums2任何一个数组拷贝完成之后就结束
  12.     while(i<nums1Size-nums2Size&&j<nums2Size)
  13.     {
  14.         if(p1[i]<p2[j])
  15.         {
  16.             arr[k]=p1[i];
  17.             i++;
  18.         }
  19.         else
  20.         {
  21.             arr[k]=p2[j];
  22.             j++;
  23.         }
  24.         k++;
  25.     }
  26.     //如果nums1先结束，将nums2中剩余的元素全部拷贝到arr
  27.     if(i==nums1Size-nums2Size)
  28.     {
  29.         for(;j<nums2Size;j++)
  30.         {
  31.             arr[k++]=p2[j];
  32.         }
  33.     }
  34.     //如果nums2先结束，将nums1中剩余的元素全部拷贝到arr
  35.     if(j==nums2Size)
  36.     {
  37.         for(;i<nums1Size-nums2Size;i++)
  38.         {
  39.             arr[k++]=p1[i];
  40.         }
  41.     }
  42.     //将arr中的元素拷贝回nums1
  43.     for(k=0;k<nums1Size;k++)
  44.     {
  45.         nums1[k]=arr[k];
  46.     }
  47. }

7.动态顺序表完整源码

1.SeqList.h

  1. #pragma once
  2. #include<stdio.h>
  3. #include<assert.h>
  4. #include<stdlib.h>
  5. #include<stdbool.h>
  6.  
  7. typedef int SLDataType;
  8.  
  9. //动态顺序表
  10. typedef struct SeqList
  11. {
  12. 	SLDataType* a;
  13. 	int size;//记录有多少个有效数据
  14. 	int capacity;//记录顺序表的容量大小
  15. }SeqList;
  16.  
  17. //初始化顺序表
  18. void SLInit(SeqList* ps);
  19. //释放空间
  20. void SLDestroy(SeqList* ps);
  21. //检查顺序表是否已满
  22. void CheakCapacity(SeqList* ps);
  23. //动态顺序表的尾插
  24. void SLPushBack(SeqList* ps, SLDataType data);
  25. //动态顺序表的尾删
  26. void SLPopBack(SeqList* ps);
  27. //动态顺序表的头插
  28. void SLPushFront(SeqList* ps, SLDataType data);
  29. //动态顺序表的头删
  30. void SLPopFront(SeqList* ps);
  31. //pos位置插入数据
  32. void SLInsert(SeqList* ps, int pos, SLDataType data);
  33. //pos位置删除数据
  34. void SLErase(SeqList* ps, int pos);
  35. //查找数据
  36. int SLFind(SeqList* ps, SLDataType data, int begin);
  37. //判断数组是否已满
  38. bool IsFull(SeqList* ps);
  39. //打印存储的数据
  40. void SLPrint(SeqList* ps);

2.SeqList.c

  1. #define _CRT_SECURE_NO_DEPRECATE 1
  2. #include"SeqList.h"
  3.  
  4. void SLInit(SeqList* ps)
  5. {
  6. 	assert(ps);
  7. 	ps->a = NULL;
  8. 	ps->size = 0;
  9. 	ps->capacity = 0;
  10. }
  11.  
  12. void SLDestroy(SeqList* ps)
  13. {
  14. 	assert(ps);
  15. 	//若ps->a不为NULL，则释放空间
  16. 	if (ps->a)
  17. 	{
  18. 		free(ps->a);
  19. 		ps->a = NULL;
  20. 		ps->capacity = ps->size = 0;
  21. 	}
  22. }
  23.  
  24. void CheakCapacity(SeqList* ps)
  25. {
  26. 	assert(ps);
  27. 	if (ps->capacity == ps->size)
  28. 	{
  29. 		//若是第一次扩容，则大小为4；
  30. 		//若不是第一次，则每次扩容为之前容量的2倍
  31. 		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
  32. 		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
  33. 		if (tmp == NULL)
  34. 		{
  35. 			perror("malloc fail");
  36. 			exit(-1);
  37. 		}
  38. 		ps->a = tmp;
  39. 		ps->capacity = newCapacity;
  40. 	}
  41. 	//检查是否做到扩容
  42. 	printf("扩容成功,现在的容量为:%d\n", ps->capacity);
  43. }
  44.  
  45. void SLPushBack(SeqList* ps, SLDataType data)
  46. {
  47. 	assert(ps);
  48. 	CheakCapacity(ps);
  49. 	//插入数据
  50. 	ps->a[ps->size] = data;
  51. 	ps->size++;
  52. }
  53.  
  54. void SLPopBack(SeqList* ps)
  55. {
  56. 	assert(ps);
  57. 	ps->size--;
  58. }
  59.  
  60. void SLPushFront(SeqList* ps, SLDataType data)
  61. {
  62. 	assert(ps);
  63. 	CheakCapacity(ps);
  64. 	//挪动数据
  65. 	for (int i = ps->size - 1; i >= 0; i--)
  66. 	{
  67. 		ps->a[i + 1] = ps->a[i];
  68. 	}
  69. 	//插入数据
  70. 	ps->a[0] = data;
  71. 	ps->size++;
  72. }
  73.  
  74. void SLPopFront(SeqList* ps)
  75. {
  76. 	assert(ps);
  77. 	assert(ps->size > 0);
  78. 	//挪动数据
  79. 	for (int i = 0; i < ps->size - 1; i++)
  80. 	{
  81. 		ps->a[i] = ps->a[i + 1];
  82. 	}
  83. 	ps->size--;
  84. }
  85.  
  86. void SLInsert(SeqList* ps, int pos, SLDataType data)
  87. {
  88. 	assert(ps);
  89. 	CheakCapacity(ps);
  90. 	//挪动数据
  91. 	for (int i = ps->size - 1; i >= pos; i--)
  92. 	{
  93. 		ps->a[i + 1] = ps->a[i];
  94. 	}
  95. 	//插入数据
  96. 	ps->a[pos] = data;
  97. 	ps->size++;
  98. }
  99.  
  100. void SLErase(SeqList* ps, int pos)
  101. {
  102. 	assert(ps);
  103. 	assert(ps->size > 0);
  104. 	//挪动数据
  105. 	for (int i = pos; i < ps->size - 1; i++)
  106. 	{
  107. 		ps->a[i] = ps->a[i + 1];
  108. 	}
  109. 	ps->size--;
  110. }
  111.  
  112. int SLFind(SeqList* ps, SLDataType data, int begin)
  113. {
  114. 	assert(ps);
  115. 	assert(begin < ps->size);
  116. 	for (int i = begin; i < ps->size; i++)
  117. 	{
  118. 		if (ps->a[i] == data)
  119. 		{
  120. 			return i;
  121. 		}
  122. 	}
  123. 	return -1;
  124. }
  125.  
  126. void SLPrint(SeqList* ps)
  127. {
  128. 	assert(ps);
  129. 	for (int i = 0; i < ps->size; i++)
  130. 	{
  131. 		printf("%d ", ps->a[i]);
  132. 	}
  133. 	printf("\n");
  134. }

 

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

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

  

闽ICP备14008679号