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

数据结构一：顺序表（C/C++实现）_数据结构顺序表的插入c++

作者：我家自动化 | 2024-05-19 23:07:49

赞

踩

数据结构顺序表的插入c++

目录

代码实现（C）：

代码实现（C++）：

结果展示：

总结：

顺序表是线性表的一种

分为静态顺序表和动态顺序表

代码实现（C）：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. #define MAXSIZE	20
  5. typedef int ElemType;
  6. typedef struct {		//静态顺序表
  7. 	ElemType data[MAXSIZE];
  8. 	int lenth;
  9. }SqList;
  10.  
  11.  
  12. //初始化静态顺序表，长度不可变
  13. void InitSqList(SqList* L)
  14. {
  15.     L->lenth = 6;//设定初始顺序表有6个数据
  16. 	for (int i = 0; i < L->lenth; i++) {
  17. 		L->data[i] = i + 1;
  18. 	}
  19. }
  20. //输出顺序表
  21. void PrintList(SqList L)
  22. {
  23. 	for (int i = 0; i < L.lenth; i++) {
  24. 		printf("data[%d]:%d     ", i, L.data[i]);
  25. 	}
  26. 	printf("\n");
  27. }
  28. //顺序表第i个位置插入元素e
  29. int SqListInsert(SqList* L, int i, ElemType e)
  30. {
  31. 	if (i < 1 || i > L->lenth + 1)	return 0;	//超出范围不能插入
  32. 	if (L->lenth >= MAXSIZE)	return 0;	//表满不能插入
  33. 	for (int j = L->lenth; j >= i; j--) {
  34. 		L->data[j] = L->data[j - 1];	//第i个位置之后的元素后移
  35. 	}
  36. 	L->data[i - 1] = e;
  37. 	L->lenth++;
  38. 	return 1;
  39. }
  40. //删除第i个元素，并返回删除的元素e
  41. int SqListDelete(SqList* L, int i, ElemType* e)
  42. {
  43. 	if (i < 1 || i > L->lenth)	return 0;	//超出范围不能删除
  44. 	if (L->lenth == 0)	return 0;	//表空不能删除
  45. 	*e = L->data[i - 1];
  46. 	for (int j = i; j < L->lenth; j++) {
  47. 		L->data[j - 1] = L->data[j];//第i个位置之后的元素前移
  48. 	}
  49. 	L->lenth--;
  50. 	return 1;
  51. }
  52. //按值查找元素，并返回位序
  53. int SqListLocateItem(SqList L, ElemType e)
  54. {
  55. 	for (int i = 0; i < L.lenth; i++) {
  56. 		if (L.data[i] == e)
  57. 			return i + 1;
  58. 	}
  59. 	return -1;	//查找失败
  60. }
  61.  
  62. int main()
  63. {
  64. 	SqList L1, L2;
  65. 	int e, temp;
  66.  
  67. 	/*******************************插入、删除、查找成功***************************/
  68. 	printf("插入、删除、查找成功测试：\n");
  69. 	InitSqList(&L1);
  70. 	printf("初始化顺序表成功！原顺序表为：\n");
  71. 	PrintList(L1);
  72. 	if (SqListInsert(&L1, 3, 100)) {//第3个位置插入100
  73. 		printf("在第3个位置插入100成功！新顺序表为：\n");
  74. 		PrintList(L1);
  75. 	}
  76. 	else {
  77. 		printf("在第3个位置插入100失败！\n");
  78. 	}
  79.  
  80. 	if (SqListDelete(&L1, 5, &e)) {//删除第5个位置的数据，并输出删除数据
  81. 		printf("删除第5个位置的元素成功！删除的元素为：%d，新顺序表为：\n",e);
  82. 		PrintList(L1);
  83. 	}
  84. 	else {
  85. 		printf("删除第5个位置的元素失败！\n");
  86. 	}
  87. 	
  88. 	temp = SqListLocateItem(L1, 6);
  89. 	if (temp != -1) {//查找6，并返回位序
  90. 		printf("查找元素“6”成功！位序为：%d\n", temp);
  91. 	}
  92. 	else {
  93. 		printf("查找失败！\n");
  94. 	}
  95. 	/****************************************************************************/
  96.  
  97. 	/*******************************插入、删除、查找失败***************************/
  98. 	printf("\n插入、删除、查找失败测试：\n");
  99. 	InitSqList(&L2);
  100. 	printf("初始化顺序表成功！原顺序表为：\n");
  101. 	PrintList(L2);
  102. 	if (SqListInsert(&L2, 9, 999)) {//第9个位置插入999
  103. 		printf("在第9个位置插入999成功！新顺序表为：\n");
  104. 		PrintList(L2);
  105. 	}
  106. 	else {
  107. 		printf("在第9个位置插入999失败！\n");
  108. 	}
  109.  
  110. 	if (SqListDelete(&L2, 8, &e)) {//删除第8个位置的数据，并输出删除数据
  111. 		printf("删除第8个位置的元素成功！删除的元素为：%d，新顺序表为：\n", e);
  112. 		PrintList(L2);
  113. 	}
  114. 	else {
  115. 		printf("删除第8个位置的元素失败！\n");
  116. 	}
  117.  
  118. 	temp = SqListLocateItem(L2, 123);
  119. 	if (temp != -1) {//查找123，并返回位序
  120. 		printf("查找元素“123”成功！位序为：%d", temp);
  121. 	}
  122. 	else {
  123. 		printf("查找元素“123”失败！\n");
  124. 	}
  125. 	/****************************************************************************/
  126.  
  127. 	system("pause");
  128. 	return 0;
  129. }
  130.  
  131. /*
  132. typedef struct {		//动态顺序表
  133. 	ElemType* data;
  134. 	int lenth;
  135. 	int data_maxsize;
  136. }D_SqList;
  137. //初始化动态顺序表，长度可变
  138. int InitDynamicSqList(D_SqList* L)
  139. {
  140.     L->data_maxsize = 20;	//设定表长为20
  141. 	L->data = (ElemType*)malloc(sizeof(ElemType) * L->data_maxsize);	//分配内存空间
  142. 	if (L->data == NULL)	return 0;
  143. 	
  144. 	for (int i = 0; i < 6; i++) {
  145. 		L->data[i] = i + 1;	//设定初始顺序表有6个数据
  146. 		L->lenth++;
  147. 	}
  148. 	return 1;
  149. }
  150. int IncreaseSize(D_SqList* L, int len)	//增加动态顺序表长度
  151. {
  152. 	ElemType* p = L->data;	//保存原数据指针
  153. 	L->data = (ElemType*)malloc(sizeof(ElemType) * (L->data_maxsize + len));//新的内存数据空间
  154. 	if (L->data == NULL)	return 0;
  156. 	for (int i = 0; i < L->lenth; i++) {
  157. 		L->data[i] = p[i];	//复制原数据
  158. 	}
  159. 	L->data_maxsize = L->data_maxsize + len;	//增加表长
  160. 	free(p);	//释放原数据空间
  161. 	p = NULL;
  163. 	return 1;
  164. }
  165. //动态顺序表与静态顺序表只有内存分配上的区别，增删查改操作基本一致
  166. */

代码实现（C++）：

  1. #include <iostream>
  2.  
  3. #define MAXSIZE	20
  4. typedef int ElemType;
  5. typedef struct {		//静态顺序表
  6. 	ElemType data[MAXSIZE];
  7. 	int lenth;
  8. }SqList;
  9.  
  10. //初始化静态顺序表，长度不可变
  11. void InitSqList(SqList& L)
  12. {
  13. 	L.lenth = 6; //设定初始顺序表有6个数据
  14. 	for (int i = 0; i < L.lenth; i++) {
  15. 		L.data[i] = i + 1;
  16. 	}
  17. }
  18. //输出顺序表
  19. void PrintList(SqList L)
  20. {
  21. 	for (int i = 0; i < L.lenth; i++) {
  22. 		std::cout << "data[" << i << "]:" << L.data[i] << "     ";
  23. 	}
  24. 	std::cout << std::endl;
  25. }
  26. //顺序表第i个位置插入元素e
  27. bool SqListInsert(SqList& L, int i, ElemType e)
  28. {
  29. 	if (i < 1 || i > L.lenth + 1)	return false;	//超出范围不能插入
  30. 	if (L.lenth >= MAXSIZE)	return false;	//表满不能插入
  31. 	for (int j = L.lenth; j >= i; j--) {
  32. 		L.data[j] = L.data[j - 1];	//第i个位置之后的元素后移
  33. 	}
  34. 	L.data[i - 1] = e;
  35. 	L.lenth++;
  36. 	return true;
  37. }
  38. //删除第i个元素，并返回删除的元素e
  39. bool SqListDelete(SqList& L, int i, ElemType& e)
  40. {
  41. 	if (i < 1 || i > L.lenth)	return false;	//超出范围不能删除
  42. 	if (L.lenth == 0)	return false;	//表空不能删除
  43. 	e = L.data[i - 1];
  44. 	for (int j = i; j < L.lenth; j++) {
  45. 		L.data[j - 1] = L.data[j];//第i个位置之后的元素前移
  46. 	}
  47. 	L.lenth--;
  48. 	return true;
  49. }
  50. //按值查找元素，并返回位序
  51. int SqListLocateItem(SqList L, ElemType e)
  52. {
  53. 	for (int i = 0; i < L.lenth; i++) {
  54. 		if (L.data[i] == e)
  55. 			return i + 1;
  56. 	}
  57. 	return -1;	//查找失败
  58. }
  59.  
  60. int main()
  61. {
  62. 	SqList L1, L2;
  63. 	int e, temp;
  64.  
  65. 	/*******************************插入、删除、查找成功***************************/
  66. 	printf("插入、删除、查找成功测试：\n");
  67. 	InitSqList(L1);
  68. 	printf("初始化顺序表成功！原顺序表为：\n");
  69. 	PrintList(L1);
  70. 	if (SqListInsert(L1, 3, 100)) {//第3个位置插入100
  71. 		printf("在第3个位置插入100成功！新顺序表为：\n");
  72. 		PrintList(L1);
  73. 	}
  74. 	else {
  75. 		printf("在第3个位置插入100失败！\n");
  76. 	}
  77.  
  78. 	if (SqListDelete(L1, 5, e)) {//删除第5个位置的数据，并输出删除数据
  79. 		printf("删除第5个位置的元素成功！删除的元素为：%d，新顺序表为：\n",e);
  80. 		PrintList(L1);
  81. 	}
  82. 	else {
  83. 		printf("删除第5个位置的元素失败！\n");
  84. 	}
  85. 	
  86. 	temp = SqListLocateItem(L1, 6);
  87. 	if (temp != -1) {//查找6，并返回位序
  88. 		printf("查找元素“6”成功！位序为：%d\n", temp);
  89. 	}
  90. 	else {
  91. 		printf("查找失败！\n");
  92. 	}
  93. 	/****************************************************************************/
  94.  
  95. 	/*******************************插入、删除、查找失败***************************/
  96. 	printf("\n插入、删除、查找失败测试：\n");
  97. 	InitSqList(L2);
  98. 	printf("初始化顺序表成功！原顺序表为：\n");
  99. 	PrintList(L2);
  100. 	if (SqListInsert(L2, 9, 999)) {//第9个位置插入999
  101. 		printf("在第9个位置插入999成功！新顺序表为：\n");
  102. 		PrintList(L2);
  103. 	}
  104. 	else {
  105. 		printf("在第9个位置插入999失败！\n");
  106. 	}
  107.  
  108. 	if (SqListDelete(L2, 8, e)) {//删除第8个位置的数据，并输出删除数据
  109. 		printf("删除第8个位置的元素成功！删除的元素为：%d，新顺序表为：\n", e);
  110. 		PrintList(L2);
  111. 	}
  112. 	else {
  113. 		printf("删除第8个位置的元素失败！\n");
  114. 	}
  115.  
  116. 	temp = SqListLocateItem(L2, 123);
  117. 	if (temp != -1) {//查找123，并返回位序
  118. 		printf("查找元素“123”成功！位序为：%d", temp);
  119. 	}
  120. 	else {
  121. 		printf("查找元素“123”失败！\n");
  122. 	}
  123. 	/****************************************************************************/
  124.  
  125. 	system("pause");
  126. 	return 0;
  127. }
  128.  
  129. /*
  130. typedef struct {		//动态顺序表
  131. 	ElemType* data;
  132. 	int lenth;
  133. 	int data_maxsize;
  134. }D_SqList;
  135. //初始化动态顺序表，长度可变
  136. bool InitDynamicSqList(D_SqList& L)
  137. {
  138. 	L.data_maxsize = 20;	//设定表长为20
  139. 	L.data = (ElemType*)malloc(sizeof(ElemType) * L.data_maxsize);	//分配内存空间
  140. 	if (L.data == NULL)	return false;
  142. 	for (int i = 0; i < 6; i++) {
  143. 		L.data[i] = i + 1;	//设定初始顺序表有6个数据
  144. 		L.lenth++;
  145. 	}
  146. 	return true;
  147. }
  148. bool IncreaseSize(D_SqList& L, int len)	//增加动态顺序表长度
  149. {
  150. 	ElemType* p = L.data;	//保存原数据指针
  151. 	L.data = (ElemType*)malloc(sizeof(ElemType) * (L.data_maxsize + len));//新的内存数据空间
  152. 	if (L.data == NULL)	return 0;
  154. 	for (int i = 0; i < L.lenth; i++) {
  155. 		L.data[i] = p[i];	//复制原数据
  156. 	}
  157. 	L.data_maxsize = L.data_maxsize + len;	//增加表长
  158. 	free(p);	//释放原数据空间
  159. 	p = NULL;
  161. 	return true;
  162. }
  163. //动态顺序表与静态顺序表只有内存分配上的区别，增删查改操作基本一致
  164. */

结果展示：

总结：

总体来说C++的引用与布尔值更好操作一些，特别是在后面链表修改指针的时候，引用更方便，也更安全；但是C的指针也不赖，在链表修改指针的时也可以使用二级指针来操作。

以上

以上均为个人学习心得，如有错误，请不吝赐教~

THE END

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

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

  

闽ICP备14008679号