• ＜顺序表及模拟实现＞——《Data Structure in C Train》

    目录

    详细实现链接：

    ＜顺序表＞《数据结构(C语言版)》

    顺序表功能实现（增删查改）《数据结构(C语言版)》

    1.线性表

    2.顺序表实现

    2.1概念及结构

    2.2 接口实现：

    后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知

    详细实现链接：

    ＜顺序表＞《数据结构(C语言版)》

    顺序表功能实现（增删查改）《数据结构(C语言版)》

    1.线性表

    线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...
    线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

    2.顺序表实现

    2.1概念及结构

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
    顺序表一般可以分为：
    1. 静态顺序表：使用定长数组存储。
    2. 动态顺序表：使用动态开辟的数组存储。

    2.2 接口实现：

    静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大
    了，空间开多了浪费，开少了不够用。所以现实中基本都是使用动态顺序表，根据需要动态
    的分配空间大小，所以下面我们实现动态顺序表。

     

     静态顺序表测试示例：

    SeqList.h:

    1. //#pragma once
    2.  
    3. #include
    4. #include
    5.  
    6. /*#ifndef  __SEQLIST__H__
    7. #define  __SEQLIST__H__
    10. 静态顺序表
    11. //struct SeqList
    12. //{
    13. //	int a[10];
    14. //	int size;
    15. //};
    16. //缺点：
    17. //1.数组大小定长，不利于变换
    18. //2.类型固定，不利于变换
    20. //静态顺序表
    21. #define N 100
    22. typedef int SQDataType;
    23. //typedef char SQDataType;    //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    25. struct SeqList
    26. {
    27. 	SQDataType a[N];
    28. 	int size;
    29. };
    31. void SeqListInit(struct SeqList sl);
    33. #endif*/
    34.  
    35.  
    36.  
    37. 静态顺序表
    38. //struct SeqList
    39. //{
    40. //	int a[10];
    41. //	int size;
    42. //};
    43. //缺点：
    44. //1.数组大小定长，不利于变换
    45. //2.类型固定，不利于变换
    46.  
    47. 写法1：
    48. 静态顺序表
    49. //#define MAX_SIZE 100
    50. //typedef int SQDataType;
    51. typedef char SQDataType;   //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    52. //
    53. //struct SeqList
    54. //{
    55. //	SQDataType a[MAX_SIZE];
    56. //	int size;
    57. //};
    58. //
    59. //void SeqListInit(struct SeqList s);
    60. //
    61. 写法2：
    62. 静态顺序表
    63. //#define MAX_SIZE 100
    64. //typedef int SQDataType;
    65. typedef char SQDataType;   //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    66. //
    67. //struct SeqList
    68. //{
    69. //	SQDataType a[MAX_SIZE];
    70. //	int size;
    71. //};
    72. //
    73. //typedef struct SeqList SL;
    74. //void SeqListInit(SL s);
    75.  
    76. //写法3：
    77. //静态顺序表
    78. #define MAX_SIZE 100
    79.  
    80. typedef int SQDataType;
    81. //typedef char SQDataType;  //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    82.  
    83. typedef struct SeqList
    84. {
    85. 	SQDataType a[MAX_SIZE];   //顺序表存储方式——数组
    86. 	int size;                 //顺序表已使用容量
    87. }SL;
    88. //静态顺序表缺点：
    89. //1.数组大小定长，不利于变换
    90. //2.类型固定，不利于变换
    91. //即：给少了不够用，给多了浪费，不能灵活控制
    92.  
    93.  
    94.  
    95.  
    96.  
    97. //顺序表初始化
    98. //void SeqListInit(SL s);
    99. void SeqListInit(SL* ps);
    100.  
    101. //顺序表尾插数据
    102. void SeqListPushBack(SL* ps, SQDataType x);
    103. //顺序表头插数据
    104. void SeqListPushFront(SL* ps, SQDataType x);
    105. //顺序表尾删数据
    106. void SeqListPopBack(SL* ps);
    107. //顺序表头删数据
    108. void SeqListPopFront(SL* ps);
    109. //打印函数
    110. void Print(SL* ps);

     SeqList.c:

    1. #include"SeqList.h"
    2.  
    3. //顺序表初始化
    4. void SeqListInit(SL* ps)
    5. {
    6. 	memset(ps->a,0,sizeof(SQDataType) * MAX_SIZE); //将数组a按字节初始化
    7. 	ps->size = 0;
    8. }
    9. //打印函数
    10. void Print(SL* ps)
    11. {
    12. 	for (int i = 0; i < ps->size; i++)
    13. 	{
    14. 		printf("%d ", ps->a[i]);
    15. 	}
    16. 	printf("\n");
    17. }
    18.  
    19. //顺序表尾插数据
    20. void SeqListPushBack(SL* ps, SQDataType x)
    21. {
    22. 	if (ps->size >= MAX_SIZE)
    23. 	{
    24. 		printf("SeqList is FULL!\n");
    25. 		return;
    26. 	}
    27. 	ps->a[ps->size] = x;
    28. 	ps->size++;    
    29. //size++在后面多加一次，是为区分数组下标与个数不同步，数组下标从0开始，而size是已使用容量个数
    30. }
    31. //顺序表头插数据
    32. void SeqListPushFront(SL* ps, SQDataType x){}
    33. //顺序表尾删数据
    34. void SeqListPopBack(SL* ps){}
    35. //顺序表头删数据
    36. void SeqListPopFront(SL* ps){}

     Test.c:

    1. #include "SeqList.h"
    2.  
    3. void TestSeqList1()
    4. {
    5. 	SL sl;
    6. 	SeqListInit(&sl); //实参传地址给形参，形参使用指针接收
    7. 	SeqListPushBack(&sl,2);
    8. 	SeqListPushBack(&sl,0);
    9. 	SeqListPushBack(&sl,2);
    10. 	SeqListPushBack(&sl,2);
    11. 	Print(&sl);
    12. }
    13.  
    14. int main()
    15. {
    16. 	TestSeqList1();
    17.  
    18. 	return 0;
    19. }

    动态顺序表：

    SeqList.h:

    1. #pragma once
    2. #define _CRT_SECURE_NO_WARNINGS
    3.  
    4. #include
    5. #include
    6. #include
    7. #include
    8. //静态顺序表
    9. ///*#ifndef  __SEQLIST__H__
    10. //#define  __SEQLIST__H__
    11. //
    12. //
    13. //静态顺序表
    14. struct SeqList
    15. {
    16. 	int a[10];
    17. 	int size;
    18. };
    19. 缺点：
    20. 1.数组大小定长，不利于变换
    21. 2.类型固定，不利于变换
    22. //
    23. 静态顺序表
    24. //#define N 100
    25. //typedef int SQDataType;
    26. typedef char SQDataType;    //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    27. //
    28. //struct SeqList
    29. //{
    30. //	SQDataType a[N];
    31. //	int size;
    32. //};
    33. //
    34. //void SeqListInit(struct SeqList sl);
    35. //
    36. //#endif*/
    37. //
    38. //
    39. //
    40. //静态顺序表
    41. struct SeqList
    42. {
    43. 	int a[10];
    44. 	int size;
    45. };
    46. 缺点：
    47. 1.数组大小定长，不利于变换
    48. 2.类型固定，不利于变换
    49. //
    50. //写法1：
    51. //静态顺序表
    52. #define MAX_SIZE 100
    53. typedef int SQDataType;
    54. //typedef char SQDataType;   //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    55.  
    56. struct SeqList
    57. {
    58. 	SQDataType a[MAX_SIZE];
    59. 	int size;
    60. };
    61.  
    62. void SeqListInit(struct SeqList s);
    63.  
    64. //写法2：
    65. //静态顺序表
    66. #define MAX_SIZE 100
    67. typedef int SQDataType;
    68. //typedef char SQDataType;   //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    69.  
    70. struct SeqList
    71. {
    72. 	SQDataType a[MAX_SIZE];
    73. 	int size;
    74. };
    75.  
    76. typedef struct SeqList SL;
    77. void SeqListInit(SL s);
    78. //
    79. 写法3：
    80. 静态顺序表
    81. //#define MAX_SIZE 100
    82. //
    83. //typedef int SQDataType;
    84. typedef char SQDataType;  //可以通过在此处改变类型，实现更换。即“一改全改”,增强程序的可维护性
    85. //
    86. //typedef struct SeqList
    87. //{
    88. //	SQDataType a[MAX_SIZE];   //顺序表存储方式——数组
    89. //	int size;                 //顺序表已使用容量
    90. //}SL;
    91. 静态顺序表缺点：
    92. 1.数组大小定长，不利于变换
    93. 2.类型固定，不利于变换
    94. 即：给少了不够用，给多了浪费，不能灵活控制
    95. //
    96. //
    97. //
    98. //
    99. //
    100. 顺序表初始化
    101. void SeqListInit(SL s);
    102. //void SeqListInit(SL* ps);
    103. // 
    104. 顺序表尾插数据
    105. //void SeqListPushBack(SL* ps, SQDataType x);
    106. 顺序表头插数据
    107. //void SeqListPushFront(SL* ps, SQDataType x);
    108. 顺序表尾删数据
    109. //void SeqListPopBack(SL* ps);
    110. 顺序表头删数据
    111. //void SeqListPopFront(SL* ps);
    112. 打印函数
    113. //void Print(SL* ps);
    114. //
    115.  
    116. //动态顺序表
    117.  
    118. typedef int SQDataType;
    119. typedef struct SeqList
    120. {
    121. 	SQDataType* a;       //顺序表存储方式——数组
    122. 	int size;            //顺序表已使用容量
    123. 	int capacity;        //顺序表总容量
    124. }SL;
    125.  
    126. //顺序表初始化
    127. //void SeqListInit(SL s);
    128. void SeqListInit(SL* ps);
    129. //顺序表打印
    130. void SeqLisPrint(SL* ps);
    131. //顺序表尾插数据
    132. void SeqListPushBack(SL* ps, SQDataType x);
    133. //顺序表头插数据
    134. void SeqListPushFront(SL* ps, SQDataType x);
    135. //顺序表尾删数据
    136. void SeqListPopBack(SL* ps);
    137. //顺序表头删数据
    138. void SeqListPopFront(SL* ps);
    139. //指定位置插入数据
    140. void SeqListInsert(SL* ps, int pos, SQDataType x);
    141. //指定位置删除数据
    142. void SeqListErase(SL* ps, int pos);
    143. //销毁、释放内存空间
    144. void SeqListDestroy(SL* ps);
    145. //顺序表查找
    146. int SeqListFind(SL* ps, SQDataType x);
    147. //顺序表修改
    148. void SeqListModify(SL* ps, int pos,SQDataType x);

       SeqList.c:

    1. #include"SeqList.h"
    2.  
    3. //顺序表初始化
    4. void SeqListInit(SL* ps)
    5. {
    6. 	ps->a = NULL;
    7. 	ps->size = 0;
    8. 	ps->capacity = 0;
    9. }
    10. //顺序表打印
    11. void SeqLisPrint(SL* ps)
    12. {
    13. 	for (int i = 0; i < ps->size; i++)
    14. 	{
    15. 		printf("%d ", ps->a[i]);
    16. 	}
    17. 	printf("\n");
    18. }
    19. //封装一个检查增容函数
    20. void SeqListCheckCapacity(SL* ps)
    21. {
    22. 	//空间满了，就扩容
    23. 	if (ps->size == ps->capacity)
    24. 	{
    25. 		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;  //防止最初capacity为0，ps->capacity * 2之后仍为0
    26. 		SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType));
    27. 		if (tmp == NULL)
    28. 		{
    29. 			printf("扩容失败！\n");
    30. 			exit(-1);
    31. 		}
    32. 		else
    33. 		{
    34. 			ps->a = tmp;
    35. 			ps->capacity = newcapacity;
    36. 		}
    37. 	}
    38. }
    39. 1.顺序表尾插数据
    40. //void SeqListPushBack(SL* ps, SQDataType x)
    41. //{
    42. //	//1.自己实现检查并增容
    43. //	空间满了，就扩容
    44. //	//if (ps->size == ps->capacity)
    45. //	//{
    46. //	//	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;  //防止最初capacity为0，ps->capacity * 2之后仍为0
    47. //	//	SQDataType* tmp = (SQDataType*)realloc(ps->a, newcapacity * sizeof(SQDataType)); 
    48. //	//	if (tmp == NULL)
    49. //	//	{
    50. //	//		printf("扩容失败！\n");
    51. //	//		exit(-1);
    52. //	//	}
    53. //	//	else
    54. //	//	{
    55. //	//		ps->a = tmp;
    56. //	//		ps->capacity = newcapacity;
    57. //	//	}
    58. //	//}
    59. //	//2.附用SeqListCheckCapacity(SL* ps)函数
    60. //	SeqListCheckCapacity(ps);
    61. //	ps->a[ps->size] = x;
    62. //	ps->size++;  //size++在后面多加一次，是为了区分数组下标与个数不同步，数组下标从0开始，而size是已使用容量个数
    63. //	
    64. //}
    65. //2.顺序表尾插数据——附用SeqListInsert
    66. void SeqListPushBack(SL* ps, SQDataType x)
    67. {
    68. 	assert(ps);
    69. 	SeqListInsert(ps, ps->size, x);
    70. }
    71. 1.顺序表头插数据
    72. //void SeqListPushFront(SL* ps, SQDataType x)
    73. //{
    74. //	SeqListCheckCapacity(ps);
    75. //	int end = ps->size - 1;
    76. //	while (end >= 0)
    77. //	{
    78. //		ps->a[end + 1] = ps->a[end];
    79. //		--end;
    80. //	}
    81. //	ps->a[0] = x;
    82. //	ps->size++;
    83. //}
    84. //2.顺序表头插数据——附用SeqListInsert
    85. void SeqListPushFront(SL* ps, SQDataType x)
    86. {
    87. 	assert(ps);
    88. 	SeqListInsert(ps, 0, x);
    89. }
    90. 1.顺序表尾删数据
    91. //void SeqListPopBack(SL* ps)
    92. //{
    93. //	assert(ps->size > 0);
    94. //	ps->size--;
    95. //}
    96. //2.顺序表尾删数据——附用SeqListErase
    97. void SeqListPopBack(SL* ps)
    98. {
    99. 	assert(ps);
    100. 	SeqListErase(ps, ps->size - 1);
    101. }
    102. 1.顺序表头删数据
    103. //void SeqListPopFront(SL* ps)
    104. //{
    105. //	assert(ps->size > 0);
    106. //	int start = 1;
    107. //	while (start < ps->size)
    108. //	{
    109. //		ps->a[start - 1] = ps->a[start];
    110. //		++start;
    111. //	}
    112. //	ps->size--;
    113. //}
    114. //2.顺序表头删数据——附用SeqListErase
    115. void SeqListPopFront(SL* ps)
    116. {
    117. 	assert(ps);
    118. 	SeqListErase(ps, 0);
    119. }
    120. //指定位置插入数据
    121. void SeqListInsert(SL* ps, int pos, SQDataType x)
    122. {
    123. 	assert(pos <= ps->size);
    124. 	SeqListCheckCapacity(ps);
    125. 	int end = ps->size - 1;
    126. 	while (end >= pos)
    127. 	{
    128. 		ps->a[end + 1] = ps->a[end];
    129. 		--end;
    130. 	}
    131. 	ps->a[pos] = x;
    132. 	ps->size++;
    133. }
    134. //指定位置删除数据
    135. void SeqListErase(SL* ps, int pos)
    136. {
    137. 	assert(ps);
    138. 	assert(pos < ps->size);
    139. 	int start = pos + 1;
    140. 	while (start < ps->size)
    141. 	{
    142. 		ps->a[start - 1] = ps->a[start];
    143. 		++start;
    144. 	}
    145. 	ps->size--;
    146. }
    147. //销毁、释放内存空间
    148. void SeqListDestroy(SL* ps)
    149. {
    150. 	assert(ps);
    151. 	free(ps->a);
    152. 	ps->a = NULL;
    153. 	ps->capacity = ps->size = 0;
    154. }
    155. //顺序表查找
    156. int SeqListFind(SL* ps, SQDataType x)
    157. {
    158. 	assert(ps);
    159. 	for (int i = 0; i < ps->size; i++)
    160. 	{
    161. 		if (ps->a[i] == x)
    162. 		{
    163. 			return i;
    164. 		}
    165. 	}
    166. 	return -1;
    167. }
    168. //顺序表修改
    169. void SeqListModify(SL* ps, int pos, SQDataType x)
    170. {
    171. 	assert(ps);
    172. 	assert(pos < ps->size);
    173. 	ps->a[pos] = x;
    174. }

    Test.c:

    1. #include "SeqList.h"
    2.  
    3. void TestSeqList1()
    4. {
    5. 	SL sl;
    6. 	SeqListInit(&sl); //实参传地址给形参，形参使用指针接收
    7. 	SeqListPushBack(&sl,2);
    8. 	SeqListPushBack(&sl,0);
    9. 	SeqListPushBack(&sl,2);
    10. 	SeqListPushBack(&sl,2);
    11. 	SeqListPushBack(&sl,0);
    12. 	SeqListPushBack(&sl,8);
    13. 	SeqListPushBack(&sl,2);
    14. 	SeqListPushBack(&sl,7);
    15.  
    16. 	SeqLisPrint(&sl);
    17. }
    18. void TestSeqList2()
    19. {
    20. 	SL sl;
    21. 	SeqListInit(&sl); 
    22. 	SeqListPushFront(&sl, 2);
    23. 	SeqListPushFront(&sl, 0);
    24. 	SeqListPushFront(&sl, 2);
    25. 	SeqListPushFront(&sl, 2);
    26. 	SeqListPushFront(&sl, 0);
    27. 	SeqListPushFront(&sl, 8);
    28. 	SeqListPushFront(&sl, 2);
    29. 	SeqListPushFront(&sl, 7);
    30.  
    31. 	SeqLisPrint(&sl);
    32. }
    33. void TestSeqList3()
    34. {
    35. 	SL sl;
    36. 	SeqListInit(&sl);
    37. 	SeqListPushFront(&sl, 2);
    38. 	SeqListPushFront(&sl, 0);
    39. 	SeqListPushFront(&sl, 2);
    40. 	SeqListPushFront(&sl, 2);
    41. 	SeqListPushFront(&sl, 0);
    42. 	SeqListPushFront(&sl, 8);
    43. 	SeqListPushFront(&sl, 2);
    44. 	SeqListPushFront(&sl, 7);
    45. 	SeqLisPrint(&sl);
    46.  
    47. 	SeqListPopBack(&sl);
    48. 	SeqLisPrint(&sl);
    49. 	SeqListPopFront(&sl);
    50. 	SeqLisPrint(&sl);
    51.  
    52.  
    53. }
    54. void TestSeqList4()
    55. {
    56. 	SL sl;
    57. 	SeqListInit(&sl);
    58. 	SeqListPushFront(&sl, 2);
    59. 	SeqListPushFront(&sl, 0);
    60. 	SeqListPushFront(&sl, 2);
    61. 	SeqListPushFront(&sl, 2);
    62. 	SeqListPushFront(&sl, 0);
    63. 	SeqListPushFront(&sl, 8);
    64. 	SeqListPushFront(&sl, 2);
    65. 	SeqListPushFront(&sl, 7);
    66. 	SeqLisPrint(&sl);
    67.  
    68. 	SeqListPopBack(&sl);
    69. 	SeqLisPrint(&sl);
    70. 	SeqListPopFront(&sl);
    71. 	SeqLisPrint(&sl);
    72.  
    73.  
    74. }
    75. void TestSeqList5()
    76. {
    77. 	SL sl;
    78. 	SeqListInit(&sl);
    79. 	SeqListPushFront(&sl, 2);
    80. 	SeqListPushFront(&sl, 0);
    81. 	SeqListPushFront(&sl, 2);
    82. 	SeqListPushFront(&sl, 2);
    83. 	SeqListPushFront(&sl, 0);
    84. 	SeqListPushFront(&sl, 8);
    85. 	SeqListPushFront(&sl, 2);
    86. 	SeqListPushFront(&sl, 7);
    87. 	SeqLisPrint(&sl);
    88.  
    89. 	SeqListInsert(&sl, 5, 1);
    90. 	SeqLisPrint(&sl);
    91. 	SeqListInsert(&sl, 7, 1);
    92. 	SeqLisPrint(&sl);
    93. }
    94. void TestSeqList6()
    95. {
    96. 	SL sl;
    97. 	SeqListInit(&sl);
    98. 	SeqListPushFront(&sl, 2);
    99. 	SeqListPushFront(&sl, 0);
    100. 	SeqListPushFront(&sl, 2);
    101. 	SeqListPushFront(&sl, 2);
    102. 	SeqListPushFront(&sl, 0);
    103. 	SeqListPushFront(&sl, 8);
    104. 	SeqListPushFront(&sl, 2);
    105. 	SeqListPushFront(&sl, 7);
    106. 	SeqLisPrint(&sl);
    107.  
    108. 	SeqListInsert(&sl, 5, 10);
    109. 	SeqLisPrint(&sl);
    110.  
    111. 	SeqListErase(&sl, 1);
    112. 	SeqLisPrint(&sl);
    113. }
    114. void TestSeqList7()
    115. {
    116. 	SL sl;
    117. 	SeqListInit(&sl);
    118. 	SeqListPushFront(&sl, 2);
    119. 	SeqListPushFront(&sl, 0);
    120. 	SeqListPushFront(&sl, 2);
    121. 	SeqListPushFront(&sl, 2);
    122. 	SeqListPushFront(&sl, 0);
    123. 	SeqListPushFront(&sl, 8);
    124. 	SeqListPushFront(&sl, 2);
    125. 	SeqListPushFront(&sl, 7);
    126. 	SeqLisPrint(&sl);
    127.  
    128. 	SeqListInsert(&sl, 5, 10);
    129. 	SeqLisPrint(&sl);
    130.  
    131. 	SeqListErase(&sl, 1);
    132. 	SeqLisPrint(&sl);
    133. 	SeqListDestroy(&sl);
    134. }
    135. void TestSeqList8()
    136. {
    137. 	SL sl;
    138. 	SeqListInit(&sl);
    139. 	SeqListPushFront(&sl, 2);
    140. 	SeqListPushFront(&sl, 0);
    141. 	SeqListPushFront(&sl, 2);
    142. 	SeqListPushFront(&sl, 2);
    143. 	SeqListPushFront(&sl, 0);
    144. 	SeqListPushFront(&sl, 8);
    145. 	SeqListPushFront(&sl, 2);
    146. 	SeqListPushFront(&sl, 7);
    147. 	SeqLisPrint(&sl);
    148. 	//查找
    149. 	
    150. 	int pos = SeqListFind(&sl, 0);
    151. 	if (pos != -1)
    152. 	{
    153. 		printf("查找下标：%d \n", pos);
    154. 	}
    155. 	
    156. 	SeqListModify(&sl, 6,9);
    157. 	SeqLisPrint(&sl);
    158. 	SeqListDestroy(&sl);
    159. }
    160. int main()
    161. {
    162. 	TestSeqList1();
    163. 	TestSeqList2();
    164. 	TestSeqList3();
    165. 	TestSeqList4();
    166. 	TestSeqList5();
    167. 	TestSeqList6();
    168. 	TestSeqList7();
    169. 	TestSeqList8();
    170.  
    171. 	return 0;
    172. }
    173.  
    174.  
    175. 菜单版
    176. //void menu()
    177. //{
    178. //	printf("****************************\n");
    179. //	printf("1.头插数据       2.尾插数据\n");
    180. //	printf("3.头删数据       4.尾删数据\n");
    181. //	printf("5.按值查找数据    6.修改数据\n");
    182. //	printf("7.打印数据       -1.退出\n");
    183. //	printf("****************************\n");
    184. //	printf("请输入你的操作选项：\n");
    185. //}
    186. //int main()
    187. //{
    188. //	SL s;
    189. //	SeqListInit(&s);
    190. //	int option = 0;
    191. //	int pos = 0;
    192. //	int x = 0;
    193. //
    194. //	while (option != -1)
    195. //	{
    196. //		menu();
    197. //		scanf("%d", &option);
    198. //		switch (option)
    199. //		{
    200. //		 
    201. //		 case 1:
    202. //			 printf("请输入你要头插的数据，以-1结束\n");
    203. //			 do {
    204. //				 scanf("%d", &x);
    205. //				 if (x != -1)
    206. //				 {
    207. //					 SeqListPushFront(&s, x);
    208. //				 }
    209. //			 } while (x != -1);
    210. //			break;
    211. //		 case 2:
    212. //			 printf("请输入你要尾插的数据，以-1结束\n");
    213. //			 do {
    214. //				 scanf("%d", &x);
    215. //				 if (x != -1)
    216. //				 {
    217. //					 SeqListPushBack(&s, x);
    218. //				 }
    219. //			 } while (x != -1);
    220. //			
    221. //			break;
    222. //		 case 3:
    223. //			 SeqListPopFront(&s);
    224. //			 printf("头删完成！\n");
    225. //
    226. //					
    227. //			break;
    228. //		 case 4:
    229. //			 SeqListPopBack(&s);
    230. //			 printf("尾删完成！\n");
    231. //
    232. //			break;
    233. //		 case 5:	
    234. //			 printf("请输入你要查找的数据:\n");
    235. //			 scanf("%d", &x);
    236. //			 int post = SeqListFind(&s, x);
    237. //			 if (post != -1)
    238. //			 {
    239. //				 printf("查找下标：%d \n", post);
    240. //			 }
    241. //			break;
    242. //		 case 6:	
    243. //			 printf("请输入你要修改的数据:\n");
    244. //			 scanf("%d", &x);
    245. //			 SeqListModify(&s, pos, x);
    246. //			break;
    247. //		 case 7:
    248. //			 SeqLisPrint(&s);
    249. //			
    250. //			break;
    251. //		 default:
    252. //			break;
    253. //		}
    254. //	}
    255. //	SeqListDestroy(&s);
    256. //	return 0;
    257. //}

    后记：
    ●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知

  • 相关阅读:
    linuxOPS基础_linux命令合集
    使用rem + sass + 媒体查询 进行横竖屏适配移动端项目
    【C++】移动距离
    filp_open
    前端工程化精讲第十二课 打包提效：如何为 Webpack 打包阶段提速？
    网络带宽监控
    在线教育项目【老师服务】
    仿制药的未来商机--个人研发的体会
    RF allure-windows 报告生成
    《动手学深度学习 Pytorch版》 6.4 多输入多输出通道
  • 原文地址：https://blog.csdn.net/m0_57859086/article/details/126552514