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

顺序表中的基本操作(详细代码图解+注释+算法步骤)_顺序表的基本操作代码

作者：繁依Fanyi0 | 2024-04-19 10:41:05

赞

踩

顺序表的基本操作代码

目录

 线性表中的顺序表基本操作的函数名类型定义：

1.创建一个长度为n的顺序表L：

        创建一个长度为n顺序表L的核心代码块：

        创建一个长度为n顺序表的完整代码如下：

        运行结果：

2.顺序表L的插入:

        顺序表L的插入的核心代码：

        顺序表L的插入的完整代码如下：

        运行结果：

3.顺序表L的删除：

        顺序表L的删除的核心代码：

        顺序表L的删除的完整代码实现如下：

        运行结果:

4.顺序表L的查找：

        顺序表的查找(按值查找) 核心代码：

        顺序表的查找(按值查找) 完整代码如下： 

        运行结果：

        顺序表的查找(按位置查找) 核心代码：

         顺序表的查找(按位置查找) 完整代码如下： 

        运行结果：

5.顺序表L的倒置：

        顺序表L的倒置的核心代码：

        顺序表L的倒置的完整代码如下：

        运行结果：

 下面是线性表中的顺序表基本操作的函数名类型定义：

  • CreateList(SqList &L,int n) ：创建长度为n的顺序表L—— 时间复杂度：O(n)
  • InitList(SqList &L) ：初始化顺序表L——时间复杂度:O(1)
  • InsertList(SqList &L,int i,ElemType e) ：在位置i处插入元素e ——时间复杂度:O(n)
  • ListDelete(SqList &L,int i)：删除位置i处元素——时间复杂度:O(n)
  • LocateElem(SqList L,ElemType e) ：返回顺序表L中第一个等于e的元素的位置——时间复杂度:O(n)
  • GetElem(SqList L, int i, ElemType &e)：根据指定的位置序号i，获取顺序表L中第i个数据元素的值——时间复杂度:O(1)
  • Reverse(SqList &L) ： 将原顺序表L直接倒置。
  • PrintList(SqList L)：遍历顺序表L，并输出。
     

1.创建一个长度为n的顺序表L：

        创建一个长度为n顺序表L的核心代码：

  1. //------顺序表初始化前n个数据------//
  2. bool CreateList(SqList &L,int n) 
  3. {
  4. 	if(n<0||n>MAXSIZE) return false; //n值不合法
  5. 	for(int i=0; i<n; i++){
  6. 		scanf("%d",&L.elem[i]);
  7. 		L.length++;
  8. 	} 
  9. 	return true;
  10. }

        创建一个长度为n顺序表的完整代码如下：

  1. //******************************创建一个长度为n的顺序表L******************************// 
  2. #include<stdio.h>
  3. #define OK 1
  4. #define ERROR 0
  5. typedef int ElemType;
  6. typedef int Status;
  7. //------顺序表的存储结构------//
  8. #define MAXSIZE 100     //顺序表可能达到的最大长度
  9. typedef struct
  10. {
  11. 	ElemType *elem; //或ElemType elem[MAXSIZE]  存储空间的基地址  
  12. 	int length;	 //当前长度 
  13. }SqList;         //顺序表的结构类型为SqList 
  14.  
  15.  
  16. //------顺序表的初始化------//
  17.  //-----【算法步骤】 -----// 
  18.   //1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
  19.   //2.将表的当前长度设为0。
  20. bool InitList(SqList &L)
  21. {
  22. 	//构造一个空的顺序表L
  23. 	L.elem=new int[MAXSIZE]; //为顺序表分配一个大小为MAXSIZE的数组空间 
  24. 	if(!L.elem)	return false;   //存储分配失败退出 
  25. 	L.length=0;                 //空表长度为0 
  26. 	return true; 
  27. }
  28.  
  29. //------顺序表初始化前n个数据------//
  30. bool CreateList(SqList &L,int n) 
  31. {
  32. 	if(n<0||n>MAXSIZE) return false; //n值不合法
  33. 	for(int i=0; i<n; i++){
  34. 		scanf("%d",&L.elem[i]);
  35. 		L.length++;
  36. 	} 
  37. 	return true;
  38. }
  39.  
  40. //------输出打印顺序表  按位置从小到大输出顺序表所有元素------//
  41. void PrintList(SqList L)
  42. {
  43. 	printf("当前顺序表中所有元素为：");
  44. 	for(int i=0; i<L.length; i++)
  45. 	{
  46. 		printf("%d ",L.elem[i]);
  47. 	}
  48. 	printf("\n");
  49.  } 
  50.  
  51. //------创建顺序表函数------//
  52. void Create(SqList &L) 
  53. {
  54. 	int n;
  55. 	bool flag;
  56. 	L.length=0;
  57. 	printf("请输入要创建的顺序表的长度：");
  58. 	scanf("%d",&n);
  59. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  60. 	flag=CreateList(L,n);
  61. 	if(flag){
  62. 		printf("顺序表创建成功！\n");
  63. 		PrintList(L);
  64. 	}
  65. 	else
  66. 		printf("输入长度不合法！\n"); 
  67. }
  68.  
  69. //------创建主函数------//
  70. int main()
  71. {
  72. 	SqList L;
  73. 	InitList(L);
  74. 	Create(L);
  75. }

        运行结果：

2.顺序表L的插入:

        顺序表L的插入的核心代码：

  1. //------顺序表的插入------//
  2.  //-----【算法步骤】 -----// 
  3.   //1.判断插入位置i是否合法(i值的合法范围是1<=i<=n+1),若不合法则返回ERROR。 
  4.   //2.判断顺序表的存储空间是否已满，若满则返回ERROR。
  5.   //3.将第n个至第i个位置的元素依次向后移动一个位置，空出第i个位置(i=n+1时无需移动)。 
  6.   //4.将要插入的新元素e放入到第i个位置。 
  7.   //5.表长加1。
  8. Status ListInsert(SqList &L, int i, int e) 
  9. {
  10. 	//在顺序表L中第i个位置插入新的元素e，i值的合法范围是1<=i<=L.length+1 
  11. 	if(i<1||(i>L.length+1)) return ERROR; //i值不合法 
  12. 	if(L.length==MAXSIZE) return ERROR; //当前存储空间已满 
  13. 	for(int j=L.length-1; j>=i-1; j--)
  14. 		L.elem[j+1]=L.elem[j]; //插入位置及之后的元素后移 
  15. 	L.elem[i-1]=e; //将新元素e放入第i个位置 
  16. 	++L.length; //表长加1 
  17. 	return OK; 
  18. }

        顺序表L的插入的完整代码如下：

  1. //******************************先创建一个长度为n的顺序表L，然后对顺序表L进行元素插入******************************// 
  2. #include<stdio.h>
  3. #define OK 1
  4. #define ERROR 0
  5. typedef int ElemType;
  6. typedef int Status;
  7. //------顺序表的存储结构------//
  8. #define MAXSIZE 100     //顺序表可能达到的最大长度
  9. typedef struct
  10. {
  11. 	ElemType *elem;    //或ElemType elem[MAXSIZE]  存储空间的基地址  
  12. 	int length;	 //当前长度 
  13. }SqList;         //顺序表的结构类型为SqList 
  14.  
  15.  
  16. //------顺序表的初始化------//
  17.  //-----【算法步骤】 -----// 
  18.   //1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
  19.   //2.将表的当前长度设为0。
  20. bool InitList(SqList &L)
  21. {
  22. 	//构造一个空的顺序表L
  23. 	L.elem=new int[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间 
  24. 	if(!L.elem)	return false;   //存储分配失败退出 
  25. 	L.length=0;                 //空表长度为0 
  26. 	return true; 
  27. }
  28.  
  29. //------顺序表初始化前n个数据------//
  30. bool CreateList(SqList &L,int n) 
  31. {
  32. 	if(n<0||n>MAXSIZE) return false; //n值不合法
  33. 	for(int i=0; i<n; i++){
  34. 		scanf("%d",&L.elem[i]);
  35. 		L.length++;
  36. 	} 
  37. 	return true;
  38. }
  39.  
  40.  
  41. //------顺序表的插入1------//
  42.  //-----【算法步骤】 -----// 
  43.   //1.判断插入位置i是否合法(i值的合法范围是1<=i<=n+1),若不合法则返回ERROR。 
  44.   //2.判断顺序表的存储空间是否已满，若满则返回ERROR。
  45.   //3.将第n个至第i个位置的元素依次向后移动一个位置，空出第i个位置(i=n+1时无需移动)。 
  46.   //4.将要插入的新元素e放入到第i个位置。 
  47.   //5.表长加1。
  48. Status ListInsert(SqList &L, int i, int e) 
  49. {
  50. 	//在顺序表L中第i个位置插入新的元素e，i值的合法范围是1<=i<=L.length+1 
  51. 	if(i<1||(i>L.length+1)) return ERROR; //i值不合法 
  52. 	if(L.length==MAXSIZE) return ERROR; //当前存储空间已满 
  53. 	for(int j=L.length-1; j>=i-1; j--)
  54. 		L.elem[j+1]=L.elem[j]; //插入位置及之后的元素后移 
  55. 	L.elem[i-1]=e; //将新元素e放入第i个位置 
  56. 	++L.length; //表长加1 
  57. 	return OK; 
  58. }
  59.  
  60. //------输出打印顺序表  按位置从小到大输出顺序表所有元素------//
  61. void PrintList(SqList L)
  62. {
  63. 	printf("当前顺序表中所有元素为：");
  64. 	for(int i=0; i<L.length; i++)
  65. 	{
  66. 		printf("%d ",L.elem[i]);
  67. 	}
  68. 	printf("\n");
  69.  } 
  70.  
  71. //------创建顺序表函数------//
  72. void Create(SqList &L) 
  73. {
  74. 	int n;
  75. 	bool flag;
  76. 	L.length=0;
  77. 	printf("请输入要创建的顺序表的长度：");
  78. 	scanf("%d",&n);
  79. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  80. 	flag=CreateList(L,n);
  81. 	if(flag){
  82. 		printf("顺序表L创建成功！\n");
  83. 		PrintList(L);
  84. 	}
  85. 	else
  86. 		printf("输入长度不合法！\n"); 
  87. }
  88.  
  89. //------插入顺序表函数------//
  90. void Insert(SqList &L)
  91. {
  92. 	int place;
  93. 	int e;
  94. 	bool flag;
  95. 	printf("请输入要插入的位置(从1开始)及元素：");
  96. 	scanf("%d%d",&place,&e);
  97. 	flag=ListInsert(L,place,e);
  98. 	if(flag)
  99. 	{
  100. 		printf("插入成功！！！\n");
  101. 		PrintList(L);
  102. 	 } 
  103. 	
  104.  } 
  105.  
  106. //------创建主函数------//
  107. int main()
  108. {
  109. 	SqList L;
  110. 	InitList(L);
  111. 	Create(L);
  112. 	Insert(L);
  113. }

        运行结果：

3.顺序表L的删除：

        顺序表L的删除的核心代码：

  1. //------顺序表的删除------//
  2.  //-----【算法步骤】 -----// 
  3.   //1.判断删除位置i是否合法(i值的合法范围是1<=i<=n),若不合法则返回ERROR。 
  4.   //2.将第i+1个至第n个的元素依次向前移动一个位置(i=n时无需移动)。 
  5.   //3.表长减1。
  6. Status ListDelete(SqList &L,int i) 
  7. {
  8. 	//在顺序表L中删除第i个元素，i值的合法范围是1<=i<=L.length
  9. 	if(i<1||(i>L.length)) return ERROR; //i值不合法 
  10. 	for(int j=i; j<=L.length-1; j++)
  11. 		L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移 
  12. 	--L.length; //表长减1 
  13. 	return OK; 
  14. }

        顺序表L的删除的完整代码实现如下：

  1. //******************************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行删除******************************// 
  2. #include<stdio.h>
  3. #define OK 1
  4. #define ERROR 0
  5. typedef int ElemType;
  6. typedef int Status;
  7. //------顺序表的存储结构------//
  8. #define MAXSIZE 100     //顺序表可能达到的最大长度
  9. typedef struct
  10. {
  11. 	ElemType *elem;    //或ElemType elem[MAXSIZE]  存储空间的基地址  
  12. 	int length;	 //当前长度 
  13. }SqList;         //顺序表的结构类型为SqList 
  14.  
  15.  
  16. //------顺序表的初始化------//
  17.  //-----【算法步骤】 -----// 
  18.   //1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
  19.   //2.将表的当前长度设为0。
  20. bool InitList(SqList &L)
  21. {
  22. 	//构造一个空的顺序表L
  23. 	L.elem=new int[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间 
  24. 	if(!L.elem)	return false;   //存储分配失败退出 
  25. 	L.length=0;                 //空表长度为0 
  26. 	return true; 
  27. }
  28.  
  29. //------顺序表初始化前n个数据------//
  30. bool CreateList(SqList &L,int n) 
  31. {
  32. 	if(n<0||n>MAXSIZE) return false; //n值不合法
  33. 	for(int i=0; i<n; i++){
  34. 		scanf("%d",&L.elem[i]);
  35. 		L.length++;
  36. 	} 
  37. 	return true;
  38. }
  39.  
  40. //------顺序表的删除------//
  41.  //-----【算法步骤】 -----// 
  42.   //1.判断删除位置i是否合法(i值的合法范围是1<=i<=n),若不合法则返回ERROR。 
  43.   //2.将第i+1个至第n个的元素依次向前移动一个位置(i=n时无需移动)。 
  44.   //3.表长减1。
  45. Status ListDelete(SqList &L,int i) 
  46. {
  47. 	//在顺序表L中删除第i个元素，i值的合法范围是1<=i<=L.length
  48. 	if(i<1||(i>L.length)) return ERROR; //i值不合法 
  49. 	for(int j=i; j<=L.length-1; j++)
  50. 		L.elem[j-1]=L.elem[j]; //被删除元素之后的元素前移 
  51. 	--L.length; //表长减1 
  52. 	return OK; 
  53. }
  54.  
  55. //------输出打印顺序表  按位置从小到大输出顺序表所有元素------//
  56. void PrintList(SqList L)
  57. {
  58. 	printf("当前顺序表中所有元素为：");
  59. 	for(int i=0; i<L.length; i++)
  60. 	{
  61. 		printf("%d ",L.elem[i]);
  62. 	}
  63. 	printf("\n");
  64.  } 
  65.  
  66. //------创建顺序表函数------//
  67. void Create(SqList &L) 
  68. {
  69. 	int n;
  70. 	bool flag;
  71. 	L.length=0;
  72. 	printf("请输入要创建的顺序表的长度：");
  73. 	scanf("%d",&n);
  74. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  75. 	flag=CreateList(L,n);
  76. 	if(flag){
  77. 		printf("顺序表L创建成功！\n");
  78. 		PrintList(L);
  79. 	}
  80. 	else
  81. 		printf("输入长度不合法！\n"); 
  82. }
  83.  
  84. //------删除顺序表函数------//
  85. void Delete(SqList &L)
  86. {
  87. 	int place;
  88. 	bool flag;
  89. 	printf("请输入要删除的位置(从1开始)：");
  90. 	scanf("%d",&place);
  91. 	flag=ListDelete(L,place);
  92. 	if(flag)
  93. 	{
  94. 		printf("删除成功！\n");
  95. 		PrintList(L);
  96. 	}
  97. }
  98.  
  99. //------创建主函数------//
  100. int main()
  101. {
  102. 	SqList L;
  103. 	InitList(L);
  104. 	Create(L);
  105. 	Delete(L);
  106. }

        运行结果:

4.顺序表L的查找：

        顺序表的查找(按值查找) 核心代码：

  1. //------顺序表的查找(按值查找)------//
  2.  //-----【算法步骤】 -----// 
  3.   //1.从第一个元素起，依次和e相比较，若找到与e相等的元素L.elem[i],则查找成功，返回该元素的序号i+1。 
  4.   //2.若查遍整个顺序表都没有找到，则查找失败，返回0。 
  5.   
  6. int LocateElem(SqList L, int e) 
  7. {
  8. 	//在顺序表L中查找值为e的数据元素，返回其序号。
  9. 	for(int i=0; i<L.length;i++)
  10. 		if(L.elem[i]==e) return i+1;  //查找成功，返回序号i+1。
  11. 	return 0;                         //查找失败，返回0。 
  12. }

        顺序表的查找(按值查找) 完整代码如下： 

  1. //************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行按值查找*************// 
  2. #include<stdio.h>
  3. #define OK 1
  4. #define ERROR 0
  5. typedef int ElemType;
  6. typedef int Status;
  7. //------顺序表的存储结构------//
  8. #define MAXSIZE 100     //顺序表可能达到的最大长度
  9. typedef struct
  10. {
  11. 	ElemType *elem;    //或ElemType elem[MAXSIZE]  存储空间的基地址  
  12. 	int length;	 //当前长度 
  13. }SqList;         //顺序表的结构类型为SqList 
  14.  
  15.  
  16. //------顺序表的初始化------//
  17.  //-----【算法步骤】 -----// 
  18.   //1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
  19.   //2.将表的当前长度设为0。
  20. bool InitList(SqList &L)
  21. {
  22. 	//构造一个空的顺序表L
  23. 	L.elem=new int[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间 
  24. 	if(!L.elem)	return false;   //存储分配失败退出 
  25. 	L.length=0;                 //空表长度为0 
  26. 	return true; 
  27. }
  28.  
  29. //------顺序表初始化前n个数据------//
  30. bool CreateList(SqList &L,int n) 
  31. {
  32. 	if(n<0||n>MAXSIZE) return false; //n值不合法
  33. 	for(int i=0; i<n; i++){
  34. 		scanf("%d",&L.elem[i]);
  35. 		L.length++;
  36. 	} 
  37. 	return true;
  38. }
  39.  
  40. //------顺序表的查找(按值查找)------//
  41.  //-----【算法步骤】 -----// 
  42.   //1.从第一个元素起，依次和e相比较，若找到与e相等的元素L.elem[i],则查找成功，返回该元素的序号i+1。 
  43.   //2.若查遍整个顺序表都没有找到，则查找失败，返回0。 
  44.   
  45. int LocateElem(SqList L, int e) 
  46. {
  47. 	//在顺序表L中查找值为e的数据元素，返回其序号。
  48. 	for(int i=0; i<L.length;i++)
  49. 		if(L.elem[i]==e) return i+1;  //查找成功，返回序号i+1。
  50. 	return 0;                         //查找失败，返回0。 
  51. }
  52.  
  53. //------输出打印顺序表  按位置从小到大输出顺序表所有元素------//
  54. void PrintList(SqList L)
  55. {
  56. 	printf("当前顺序表中所有元素为：");
  57. 	for(int i=0; i<L.length; i++)
  58. 	{
  59. 		printf("%d ",L.elem[i]);
  60. 	}
  61. 	printf("\n");
  62.  } 
  63.  
  64. //------创建顺序表函数------//
  65. void Create(SqList &L) 
  66. {
  67. 	int n;
  68. 	bool flag;
  69. 	L.length=0;
  70. 	printf("请输入要创建的顺序表的长度：");
  71. 	scanf("%d",&n);
  72. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  73. 	flag=CreateList(L,n);
  74. 	if(flag){
  75. 		printf("顺序表L创建成功！\n");
  76. 		PrintList(L);
  77. 	}
  78. 	else
  79. 		printf("输入长度不合法！\n"); 
  80. }
  81.  
  82. //------查找顺序表函数------//
  83. void Search(SqList L)
  84. {
  85. 	int e,flag;
  86. 	printf("请输入要查找的值：");
  87. 	scanf("%d",&e);
  88. 	flag=LocateElem(L,e);
  89. 	if(flag)
  90. 	{
  91. 		printf("该元素的位置为：%d\n",flag);
  92. 		printf("查找成功！"); 
  93. 	 }
  94. 	else
  95. 		printf("未查找到该元素！"); 
  96.  } 
  97. //------创建主函数------//
  98. int main()
  99. {
  100. 	SqList L;
  101. 	InitList(L);
  102. 	Create(L);
  103. 	Search(L);
  104. }

        运行结果：

        顺序表的查找(按位置查找) 核心代码：

  1. //------顺序表的查找(按位置查找)------//
  2.  //-----【算法步骤】 -----// 
  3.   //1.判断指定的位置序号i值是否合理(1<=i<=L.length)，若不合理，则返回ERROR。 
  4.   //2.若i值合理，则将第i个数据元素L.length[i-1]赋值给参数e，通过e返回第i个数据元素的传值。 
  5.   
  6. Status GetElem(SqList L, int i, int &e)
  7. {
  8. 	if(i<1||i>L.length) return ERROR;  //判断i值是否合理
  9. 	e=L.elem[i-1];                     //elem[i-1]单元存储第i个数据元素 
  10. 	return OK; 
  11.  }

         顺序表的查找(按位置查找) 完整代码如下： 

  1. //****************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行按位置查找****************// 
  2. #include<stdio.h>
  3. #define OK 1
  4. #define ERROR 0
  5. typedef int ElemType;
  6. typedef int Status;
  7. //------顺序表的存储结构------//
  8. #define MAXSIZE 100     //顺序表可能达到的最大长度
  9. typedef struct
  10. {
  11. 	ElemType *elem;    //或ElemType elem[MAXSIZE]  存储空间的基地址  
  12. 	int length;	 //当前长度 
  13. }SqList;         //顺序表的结构类型为SqList 
  14.  
  15.  
  16. //------顺序表的初始化------//
  17.  //-----【算法步骤】 -----// 
  18.   //1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
  19.   //2.将表的当前长度设为0。
  20. bool InitList(SqList &L)
  21. {
  22. 	//构造一个空的顺序表L
  23. 	L.elem=new int[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间 
  24. 	if(!L.elem)	return false;   //存储分配失败退出 
  25. 	L.length=0;                 //空表长度为0 
  26. 	return true; 
  27. }
  28.  
  29. //------顺序表初始化前n个数据------//
  30. bool CreateList(SqList &L,int n) 
  31. {
  32. 	if(n<0||n>MAXSIZE) return false; //n值不合法
  33. 	for(int i=0; i<n; i++){
  34. 		scanf("%d",&L.elem[i]);
  35. 		L.length++;
  36. 	} 
  37. 	return true;
  38. }
  39.  
  40. //------顺序表的查找(按位置查找)------//
  41.  //-----【算法步骤】 -----// 
  42.   //1.判断指定的位置序号i值是否合理(1<=i<=L.length)，若不合理，则返回ERROR。 
  43.   //2.若i值合理，则将第i个数据元素L.length[i-1]赋值给参数e，通过e返回第i个数据元素的传值。 
  44.   
  45. Status GetElem(SqList L, int i, int &e)
  46. {
  47. 	if(i<1||i>L.length) return ERROR;  //判断i值是否合理
  48. 	e=L.elem[i-1];                     //elem[i-1]单元存储第i个数据元素 
  49. 	return OK; 
  50.  } 
  51.  
  52. //------输出打印顺序表  按位置从小到大输出顺序表所有元素------//
  53. void PrintList(SqList L)
  54. {
  55. 	printf("当前顺序表中所有元素为：");
  56. 	for(int i=0; i<L.length; i++)
  57. 	{
  58. 		printf("%d ",L.elem[i]);
  59. 	}
  60. 	printf("\n");
  61.  } 
  62.  
  63. //------创建顺序表函数------//
  64. void Create(SqList &L) 
  65. {
  66. 	int n;
  67. 	bool flag;
  68. 	L.length=0;
  69. 	printf("请输入要创建的顺序表的长度：");
  70. 	scanf("%d",&n);
  71. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  72. 	flag=CreateList(L,n);
  73. 	if(flag){
  74. 		printf("顺序表L创建成功！\n");
  75. 		PrintList(L);
  76. 	}
  77. 	else
  78. 		printf("输入长度不合法！\n"); 
  79. }
  80.  
  81. //------查找顺序表函数------//
  82. void Get(SqList L)
  83. {
  84. 	int e,i,flag;
  85. 	printf("请输入要查找的位置：");
  86. 	scanf("%d",&i);
  87. 	flag=GetElem(L,i,e);
  88. 	if(flag)
  89. 	{
  90. 		printf("该位置的元素为：%d\n",e);
  91. 		printf("查找成功！"); 
  92. 	 }
  93. 	else
  94. 		printf("未查找到该元素！"); 
  95.  } 
  96. //------创建主函数------//
  97. int main()
  98. {
  99. 	SqList L;
  100. 	InitList(L);
  101. 	Create(L);
  102. 	Get(L);
  103. }

        运行结果：

5.顺序表L的倒置：

        顺序表L的倒置的核心代码：

  1. //------顺序表L的倒置------//
  2. void ReverseList(SqList &L)
  3. {
  4. 	//顺序表L的逆置 
  5. 	for(int i=0;i<L.length/2;i++)  //
  6. 	{
  7. 		//交换数据 
  8. 		int temp=L.elem[i];
  9. 		L.elem[i]=L.elem[L.length-1-i];
  10. 		L.elem[L.length-1-i]=temp;	
  11. 	}
  12.   }

        顺序表L的倒置的完整代码如下：

  1. //******************************先创建一个长度为n的顺序表L，然后对顺序表L中的元素进行倒置******************************// 
  2. #include<stdio.h>
  3. #define OK 1
  4. #define ERROR 0
  5. typedef int ElemType;
  6. typedef int Status;
  7. //------顺序表的存储结构------//
  8. #define MAXSIZE 100     //顺序表可能达到的最大长度
  9. typedef struct
  10. {
  11. 	ElemType *elem;    //或ElemType elem[MAXSIZE]  存储空间的基地址  
  12. 	int length;	 //当前长度 
  13. }SqList;         //顺序表的结构类型为SqList 
  14.  
  15.  
  16. //------顺序表的初始化------//
  17.  //-----【算法步骤】 -----// 
  18.   //1.为顺序表 L动态分配一个预定义大小的数组空间，使elem指向这段空间的基地址。
  19.   //2.将表的当前长度设为0。
  20. bool InitList(SqList &L)
  21. {
  22. 	//构造一个空的顺序表L
  23. 	L.elem=new int[MAXSIZE];     //为顺序表分配一个大小为MAXSIZE的数组空间 
  24. 	if(!L.elem)	return false;   //存储分配失败退出 
  25. 	L.length=0;                 //空表长度为0 
  26. 	return true; 
  27. }
  28.  
  29. //------顺序表初始化前n个数据------//
  30. bool CreateList(SqList &L,int n) 
  31. {
  32. 	if(n<0||n>MAXSIZE) return false; //n值不合法
  33. 	for(int i=0; i<n; i++){
  34. 		scanf("%d",&L.elem[i]);
  35. 		L.length++;
  36. 	} 
  37. 	return true;
  38. }
  39.  
  40. //------顺序表L的倒置------//
  41. void ReverseList(SqList &L)
  42. {
  43. 	//顺序表L的逆置 
  44. 	for(int i=0;i<L.length/2;i++)  //
  45. 	{
  46. 		//交换数据 
  47. 		int temp=L.elem[i];
  48. 		L.elem[i]=L.elem[L.length-1-i];
  49. 		L.elem[L.length-1-i]=temp;	
  50. 	}
  51.   }  
  52.  
  53.  
  54. //------输出打印顺序表  按位置从小到大输出顺序表所有元素------//
  55. void PrintList(SqList L)
  56. {
  57. 	printf("当前顺序表中所有元素为：");
  58. 	for(int i=0; i<L.length; i++)
  59. 	{
  60. 		printf("%d ",L.elem[i]);
  61. 	}
  62. 	printf("\n");
  63.  } 
  64.  
  65. //------创建顺序表函数------//
  66. void Create(SqList &L) 
  67. {
  68. 	int n;
  69. 	bool flag;
  70. 	L.length=0;
  71. 	printf("请输入要创建的顺序表的长度：");
  72. 	scanf("%d",&n);
  73. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  74. 	flag=CreateList(L,n);
  75. 	if(flag){
  76. 		printf("顺序表L创建成功！\n");
  77. 		PrintList(L);
  78. 	}
  79. 	else
  80. 		printf("输入长度不合法！\n"); 
  81. }
  82.  
  83. //------倒置顺序表函数------//
  84. void Reverse(SqList L)
  85. {    
  86. 	ReverseList(L);
  87. 	printf("顺序表L倒置后为：");
  88. 	for(int i=0; i<L.length; i++)
  89. 	{
  90. 		printf("%d ",L.elem[i]);
  91. 	}
  92. }
  93. //------创建主函数------//
  94. int main()
  95. {
  96. 	SqList L;
  97. 	InitList(L);
  98. 	Create(L);
  99. 	Reverse(L);
  100. }

        运行结果：

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

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

  

闽ICP备14008679号