学习Linux C编程之线性表

1、概念

线性表：是具有相同属性的数据元素的一个有限序列

线性表的逻辑结构示意图：

线性表的存储结构分为：顺序、链接、索引和散列等，常见的是顺序存储和链接存储（单链表和双链表）。

2、线性表的顺序存储结构

线性表的顺序存储结构：把线性表中的所有元素按照其逻辑顺序依次存储到计算机存储器中从指定存储位置开始的一块连续的存储空间中，可直接用数组表示。

线性表的顺序存储结构示意图：

下面是通过一个实例实现顺序存储结构的操作，实例中包含16种操作实现，在其他程序中可直接套用：

[cpp]  view plain  copy

1. // 线性表的顺序存储结构的操作实现  
2. #include<stdio.h>  
3. #include<stdlib.h>  
4. typedef int ElemType;       //定义元素类型  
5. struct List                //定义单链表结点类型  
6. {  
7.     ElemType *list;//存储空间基址  
8.     int size;      //当前长度  
9.     int MaxSize;   //当前分配的存储容量，即存储线性表的最大长度  
10. };  
11.   
12. //1、初始化线性表L，即进行动态存储空间分配并置L为一个空表  
13. void InitList(struct List *L, int ms)  
14. {  
15.     if (ms < 0) //检查ms是否有效  
16.     {  
17.         printf("ms值非法！\n");  
18.         exit(1);  
19.     }  
20.     L->MaxSize = ms; //置线性表初始存储容量为ms  
21.     L->list = (ElemType *)malloc(ms*sizeof(ElemType)); //动态存储空间分配  
22.     if (!L->list)  
23.     {  
24.         printf("动态存储分配失败！\n");  
25.         exit(1);  
26.     }  
27.     L->size = 0; //初始置线性表为空  
28. }  
29.   
30. //2、清除线性表L中的所有元素，释放动态存储空间，使之成为一个空表  
31. void ClearList(struct List *L)  
32. {  
33.     if (L->list != NULL)  
34.     {  
35.         free(L->list);  
36.         L->list = 0;  
37.         L->size = L->MaxSize = 0;  
38.     }  
39. }  
40.   
41. //3、返回线性表L的长度，若L为空则返回0  
42. int SizeList(struct List *L)  
43. {  
44.     return L->size;  
45. }  
46.   
47. //4、判断线性表L是否为空，若为空则返回1，否则返回0  
48. int EmptyList(struct List *L)  
49. {  
50.     if (L->size == 0)  
51.         return 1;  
52.     else  
53.         return 0;  
54. }  
55.   
56. //5、返回线性表L中第pos个元素的值，若pos超出范围，则停止程序运行  
57. ElemType GetElem(struct List *L, int pos)  
58. {  
59.     if (pos < 1 || pos > L->size)  
60.     {  
61.         printf("元素序号越界！\n");  
62.         exit(1);  
63.     }  
64.     return L->list[pos - 1];  
65. }  
66.   
67. //6、顺序扫描（即遍历）输出线性表L中的每个元素  
68. void TraverseList(struct List *L)  
69. {  
70.     int i;  
71.     for (i = 0; i < L->size; i++)  
72.         printf("%d,", L->list[i]);  
73.     printf("\n");  
74. }  
75.   
76. //7、从线性表L中查找值与x相等的元素（第一个），若查找成功则返回其位置（下标），否则返回-1  
77. int FindList(struct List *L, ElemType x)  
78. {  
79.     int i;  
80.     for (i = 0; i < L->size; i++) //此处类型ElemType为整型，当为字符串类型（char *）时，  
81.         if (L->list[i] == x)      //if语句应改为: if (strcmp(L->list[i], x) == 0)  
82.             return i;  
83.     return -1;  
84. }  
85.   
86. //8、把线性表L中第pos个元素的值修改为x的值，若修改成功返回1，否则返回0  
87. int UpdatePosList(struct List *L, int pos, ElemType x)  
88. {  
89.     if (pos < 1 || pos > L->size)  //若pos越界则修改失败  
90.         return 0;  
91.     L->list[pos - 1] = x;  
92.     return 1;  
93. }  
94.   
95. //9、向线性表L的表头插入元素x  
96. //此时需要考虑到线性表存储空间已满的情况，则需要重新分配更大的动态存储空间，具体实现如下：  
97. void againMalloc(struct List *L)  
98. {  
99.     ElemType *p = realloc(L->list, 2*L->MaxSize*sizeof(ElemType));//此处重新分配的空间为原来的2倍  
100.     if (!p)  //重新分配失败  
101.     {  
102.         printf("存储空间用完！\n");  
103.         exit(1);  
104.     }  
105.     L->list = p;             //使list指向新线性表空间  
106.     L->MaxSize = 2 * L->MaxSize;  
107.     printf("存储空间已扩大为当前的2倍！\n");//输出提示已扩充空间  
108. }  
109.   
110. void InserFirstList(struct List *L, ElemType x) //表头插入元素  
111. {  
112.     int i;  
113.     if (L->size == L->MaxSize) //存储空间已满  
114.         againMalloc(L);        //重新分配更大空间  
115.     for (i = L->size - 1; i >= 0; i--)  
116.         L->list[i + 1] = L->list[i];  
117.     L->list[0] = x;  
118.     L->size++;  
119. }  
120.   
121. //10、向线性表L的表尾插入元素x  
122. void InsertLastList(struct List *L, ElemType x)  
123. {  
124.     if (L->size == L->MaxSize)  
125.         againMalloc(L);  
126.     L->list[L->size] = x;  
127.     L->size++;  
128. }  
129.   
130. //11、向线性表L中第pos个元素位置插入元素x，若插入成功返回1，否则返回0  
131. int InsertPosList(struct List *L, int pos, ElemType x)  
132. {  
133.     int i;  
134.     if (pos < 1 || pos > L->size + 1) //pos的合法位置是第一位到最后一位的后一位之间  
135.         return 0;  
136.     if (L->size == L-> MaxSize)  
137.         againMalloc(L);  
138.     for (i = L->size - 1; i >= pos - 1; i--)  
139.         L->list[i + 1] = L->list[i];  
140.     L->list[pos - 1] = x;  
141.     L->size++;  
142.     return 1;  
143. }  
144.   
145. //12、向有序（递增）线性表L中插入元素x，使得插入后仍然有序  
146. void InsertOrderList(struct List *L, ElemType x)  
147. {  
148.     int i, j;  
149.     if (L->size == L->MaxSize)  
150.         againMalloc(L);  
151.     for (i = 0; i < L->size; i++)  
152.         if (x < L->list[i])  
153.             break;   //此时i的值即为要插入的位置。若x比所有元素都大，则i自增后的值为size，下面的for循环不执行。  
154.     for (j = L->size - 1; j >= i; j--)  
155.         L->list[j + 1] = L->list[j];  
156.     L->list[i] = x;  
157.     L->size++;  
158. }  
159.   
160. //13、从线性表L中删除表头元素并返回它，若删除失败则停止程序运行  
161. ElemType DeleteFirstList(struct List *L)  
162. {  
163.     ElemType temp; //临时变量，用于存储表头元素  
164.     int i;  
165.     if (L->size == 0)  
166.     {  
167.         printf("线性表为空，不能删除！\n");  
168.         exit(1);  
169.     }  
170.     temp = L->list[0];  
171.     for (i = 1; i < L->size; i++)  
172.         L->list[i - 1] = L->list[i];  
173.     L->size--;  
174.     return temp;  
175. }  
176.   
177. //14、从线性表L中删除表尾元素并返回它，若删除失败则停止程序运行  
178. ElemType DeleteLastList(struct List *L)  
179. {  
180.     if (L->size == 0)  
181.     {  
182.         printf("线性表为空，不能删除！\n");  
183.         exit(1);  
184.     }  
185.     L->size--;  
186.     return L->list[L->size];  
187. }  
188.   
189. //15、从线性表L中删除第pos个元素并返回它，若删除失败则停止程序运行  
190. ElemType DeletePosList(struct List *L, int pos)  
191. {  
192.     ElemType temp;  
193.     int i;  
194.     if (pos < 1 || pos > L->size)  
195.     {  
196.         printf("pos值越界，不能删除！\n");  
197.         exit(1);  
198.     }  
199.     temp = L->list[pos - 1];  
200.     for (i = pos; i < L->size; i++)  
201.         L->list[i - 1] = L->list[i];  
202.     L->size--;  
203.     return temp;  
204. }  
205.   
206. //16、从线性表L中删除值为x的第一个元素，若删除成功返回1否则返回0  
207. int DeleteValueList(struct List *L, ElemType x)  
208. {  
209.     int i, j;  
210.     for (i = 0; i < L->size; i++)  
211.         if (L->list[i] == x)  
212.             break; //此时的i即是要删除的位置,  
213.     if (i == L->size)//若找不到，上面的i自增后为size  
214.         return 0;  
215.     for (j = i + 1; j < L->size; j++)  
216.         L->list[j - 1] = L->list[j];  
217.     L->size--;  
218.     return 1;  
219. }  
220.   
221.   
222. //主函数  
223. void main()  
224. {  
225.     int a[10] = {2,4,6,8,10,12,14,16,18,20};  
226.     int i;  
227.     struct List L;  
228.     InitList(&L, 5);                 //初始化分配线性表空间为5  
229.     for (i = 0; i < 10; i++)  
230.         InsertLastList(&L, a[i]);    //将数组中的元素依次插入线性表（空间不够，扩大2倍）  
231.     InsertPosList(&L, 11, 48);       //在第11位插入48（空间不够，再次扩大2倍）  
232.     InsertPosList(&L, 1, 64);        //在第1位插入64  
233.     printf("%d\n", GetElem(&L, 4));  //输出第4个元素  
234.     TraverseList(&L);                //遍历输出所有元素  
235.     printf("%d\n", FindList(&L, 10));//查找输出数值为10的元素位置（下标）  
236.     UpdatePosList(&L, 3, 20);        //把第三个元素修改为20  
237.     DeleteFirstList(&L);             //删除表头元素  
238.     DeleteFirstList(&L);  
239.     DeleteLastList(&L);              //删除表尾元素  
240.     DeleteLastList(&L);  
241.     DeletePosList(&L, 5);            //删除第5个元素  
242.     DeletePosList(&L, 7);            //删除第7个元素  
243.     printf("%d\n", SizeList(&L));    //输出线性表长度  
244.     printf("%d\n", EmptyList(&L));   //判断线性表是否为空  
245.     TraverseList(&L);                //遍历输出所有元素  
246.     ClearList(&L);                   //清空线性表，释放空间  
247. }  

运行结果：

3、单链表

在每个结点中除包含有数值域外，只设置一个指针域，用以指向其后继结点，这样构成的链接表被称为线性单向链接表，简称单向链表或单链表。

单链表存储结构示意图：

下面是通过一个实例实现单链表的操作，实例中包含16种操作实现，在其他程序中可直接套用：

[cpp]  view plain  copy

1. //线性表在单链表上的操作实现  
2. #include<stdio.h>  
3. #include<stdlib.h>  
4. #define NN 12  
5. #define MM 20  
6. typedef int ElemType;  //定义元素类型  
7. struct sNode           //定义单链表结点类型  
8. {  
9.     ElemType data;  
10.     struct sNode* next;  
11. };  
12.   
13. //1、初始化线性表，即置单链表的表头指针为空  
14. void InitList(struct sNode** HL)  
15. {  
16.     *HL = NULL;  
17. }  
18.   
19. //2、清除线性表L的所有元素，即释放单链表的所有结点，使之成为空表  
20. void ClearList(struct sNode** HL)  
21. {  
22.     struct sNode *cp, *np;  //定义两个相邻结点的指针  
23.     cp = *HL;               //头指针赋给cp  
24.     while (cp != NULL)  
25.     {  
26.         np = cp->next;      //用np保存下一个结点的指针  
27.         free(cp);           //释放cp指向的结点  
28.         cp = np;            //使下一个结点成为当前结点  
29.     }  
30.     *HL = NULL;             //置单链表的表头指针为空  
31. }  
32.   
33. //3、返回单链表的长度  
34. int SizeList(struct sNode* HL)  
35. {  
36.     int i = 0;  
37.     while (HL != NULL)  
38.     {  
39.         i++;  
40.         HL = HL->next;  
41.     }  
42.     return i;  
43. }  
44.   
45. //4、检查单链表是否为空，若为空则返回1否则返回0  
46. int EmptyList(struct sNode* HL)  
47. {  
48.     if (HL == NULL)  
49.         return 1;  
50.     else  
51.         return 0;  
52. }  
53.   
54. //5、返回单链表中第pos个结点的元素，若pos超出范围，则停止程序运行  
55. ElemType GetElem(struct sNode* HL, int pos)  
56. {  
57.     int i = 0;  
58.     if (pos < 1)  
59.     {  
60.         printf("pos值非法，退出运行！\n");  
61.         exit(1);  
62.     }  
63.     while (HL != NULL)  
64.     {  
65.         i++;  
66.         if (i == pos)  
67.             break;  
68.         HL = HL->next;  
69.     }  
70.     if (HL != NULL)  
71.         return HL->data;  
72.     else  
73.     {  
74.         printf("pos值非法，退出运行！\n");  
75.         exit(1);  
76.     }  
77. }  
78.   
79. //6、遍历一个单链表  
80. void TraverseList(struct sNode* HL)  
81. {  
82.     while (HL != NULL)  
83.     {  
84.         printf("%d,", HL->data);  
85.         HL = HL->next;  
86.     }  
87.     printf("\n");  
88. }  
89.   
90. //7、从单链表中查找具有给定值x的第一个元素的，成功返回结点data域的存储地址，否则返回NULL  
91. ElemType* FindList(struct sNode* HL, ElemType x)  
92. {  
93.     while (HL != NULL)  
94.     {  
95.         if (HL->data == x)  
96.             return &HL->data;  
97.         else  
98.             HL = HL->next;  
99.     }  
100.     return NULL;  
101. }  
102.   
103. //8、修改单链表中第pos个结点的值为x，成功返回1失败返回0  
104. int UpdatePosList(struct sNode* HL, int pos, ElemType x)  
105. {  
106.     int i = 0;  
107.     struct sNode* p = HL;  
108.     while (p != NULL)  
109.     {  
110.         i++;  
111.         if (pos == i)  
112.             break;  
113.         else  
114.             p = p->next;  
115.     }  
116.     if (pos == i)  
117.     {  
118.         p->data = x;  
119.         return 1;  
120.     }  
121.     else  
122.         return 0;  
123. }  
124.   
125. //9、向单链表表头插入一个元素  
126. void InsertFirstList(struct sNode** HL, ElemType x)  
127. {  
128.     struct sNode *newp;  
129.     newp = malloc(sizeof(struct sNode));  
130.     if (newp == NULL)  
131.     {  
132.         printf("内存动态空间用完，退出运行！\n");  
133.         exit(1);  
134.     }  
135.     newp->data = x;  
136.     newp->next = *HL;  
137.     *HL = newp;          //把新节点作为新的表头结点  
138. }  
139.   
140. //10、向单链表的末尾添加一个元素  
141. void InsertLastList(struct sNode** HL, ElemType x)  
142. {  
143.     struct sNode *newp;  
144.     newp = malloc(sizeof(struct sNode));  
145.     if (newp == NULL)  
146.     {  
147.         printf("动态内存空间用完，退出运行！\n");  
148.         exit(1);  
149.     }  
150.     newp->data = x;  
151.     newp->next = NULL;  
152.     if (*HL == NULL)   //若原表为空  
153.         *HL = newp;  
154.     else  
155.     {  
156.         struct sNode* p = *HL;  
157.         while (p->next != NULL)  
158.             p = p->next;  
159.         p->next = newp;  
160.     }  
161. }  
162.   
163. //11、向单链表中第pos个结点位置插入元素x，成功返回1失败返回0  
164. int InsertPosList(struct sNode** HL, int pos, ElemType x)  
165. {  
166.     int i = 0;  
167.     struct sNode *newp;  
168.     struct sNode *cp = *HL, *ap = NULL;  
169.     if (pos <= 0)  
170.     {  
171.         printf("pos值不正确，返回0表示插入失败！\n");  
172.         return 0;  
173.     }  
174.     while (cp != NULL)  
175.     {  
176.         i++;  
177.         if (pos == i)  
178.             break;  
179.         else  
180.         {  
181.             ap = cp;  
182.             cp = cp->next;  
183.         }  
184.     }  
185.     newp = malloc(sizeof(struct sNode));  
186.     if (newp == NULL)  
187.     {  
188.         printf("内存动态空间用完，无法插入！\n");  
189.         return 0;  
190.     }  
191.     newp->data = x;  
192.     if (ap == NULL)    //插入表头的情况  
193.     {  
194.         newp->next = cp;  
195.         *HL = newp;  
196.     }  
197.     else              //插入到ap与cp之间的情况  
198.     {  
199.         newp->next = cp;  
200.         ap->next = newp;  
201.     }  
202.     return 1;  
203. }  
204.   
205. //12、向有序单链表中插入元素x，使得插入之后仍然有序  
206. void InsertOrderList(struct sNode** HL, ElemType x)  
207. {  
208.     struct sNode* cp = *HL, *ap = NULL;  
209.     struct sNode *newp;  
210.     newp = malloc(sizeof(struct sNode));  
211.     if (newp == NULL)  
212.     {  
213.         printf("内存动态空间用完，退出运行！\n");  
214.         exit(1);  
215.     }  
216.     newp->data = x;  
217.     if (cp == NULL || x < cp->data)   //把新结点插入到表头  
218.     {  
219.         newp->next = cp;  
220.         *HL = newp;  
221.         return;  
222.     }  
223.     while (cp != NULL)  
224.     {  
225.         if (x < cp->data)  
226.             break;  
227.         else  
228.         {  
229.             ap = cp;  
230.             cp = cp->next;  
231.         }  
232.     }  
233.     newp->next = cp;  //把x结点插入到ap与cp之间  
234.     ap->next = newp;  
235. }  
236.   
237. //13、从单链表中删除头结点，并返回结点值，失败则停止程序运行  
238. ElemType DeleteFirstList(struct sNode** HL)  
239. {  
240.     ElemType temp;  
241.     struct sNode* p = *HL;    //暂存表头结点指针  
242.     if (*HL == NULL)  
243.     {  
244.         printf("单链表为空，无表头删除，退出运行！\n");  
245.         exit(1);  
246.     }  
247.     *HL = (*HL)->next;  
248.     temp = p->data;           //暂存表头元素  
249.     free(p);  
250.     return temp;  
251. }  
252.   
253. //14、从单链表中删除尾结点并返回它的值，失败则停止程序运行  
254. ElemType DeleteLastList(struct sNode** HL)  
255. {  
256.     ElemType temp;  
257.     struct sNode* cp = *HL;  
258.     struct sNode* ap = NULL;  
259.     if (cp == NULL)  
260.     {  
261.         printf("单链表为空，无表尾删除，退出运行！\n");  
262.         exit(1);  
263.     }  
264.     while (cp->next != NULL)  
265.     {  
266.         ap = cp;  
267.         cp = cp->next;  
268.     }  
269.     if (ap == NULL)  //若单链表只有一个结点  
270.         *HL = (*HL)->next;  
271.     else  
272.         ap->next = NULL;  
273.     temp = cp->data;  
274.     free(cp);  
275.     return temp; //把新节点作为新的表头结点  
276. }  
277.   
278. //15、从单链表删除第pos个结点并返回它的值，失败则停止程序运行  
279. ElemType DeletePosList(struct sNode** HL, int pos)  
280. {  
281.     int i = 0;  
282.     ElemType temp;  
283.     struct sNode* cp = *HL;  
284.     struct sNode* ap = NULL;  
285.     if (cp == NULL || pos <= 0)  
286.     {  
287.         printf("单链表为空或pos值不正确，退出运行！\n");  
288.         exit(1);  
289.     }  
290.     while (cp != NULL)  
291.     {  
292.         i++;  
293.         if (i == pos)  
294.             break;  
295.         ap = cp;  
296.         cp = cp->next;  
297.     }  
298.     if (cp == NULL)    //单链表中没有第pos个结点  
299.     {  
300.         printf("pos值不正确，退出运行！\n");  
301.         exit(1);  
302.     }  
303.     if (pos == 1)   //删除表头结点  
304.         *HL = (*HL)->next;   //或：*HL = cp->next;  
305.     else  
306.         ap->next = cp->next;  
307.     temp = cp->data;  
308.     free(cp);  
309.     return temp;  
310. }  
311.   
312. //16、从单链表中删除值为x的第一个结点，成功返回1失败返回0  
313. int DeleteValueList(struct sNode** HL, ElemType x)  
314. {  
315.     struct sNode* cp = *HL;  
316.     struct sNode* ap = NULL;  
317.     while (cp != NULL)  
318.     {  
319.         if (cp->data == x)  
320.             break;  
321.         ap = cp;  
322.         cp = cp->next;  
323.     }  
324.     if (cp == NULL)    //单链表中不存在值为x的结点  
325.         return 0;  
326.     if (ap == NULL)    //在表头位置  
327.         *HL = (*HL)->next;   //或：*HL = cp->next;  
328.     else  
329.         ap->next = cp->next;  
330.     free(cp);  
331.     return 1;  
332. }  
333.   
334.   
335. //主函数  
336. void main()  
337. {  
338.     int a[NN];  
339.     int i;  
340.     struct sNode *p, *h, *s;  
341.     InitList(&p);                   //初始化，置单链表表头为空  
342.     for (i = 0; i < NN; i++)        //产生12个随机数  
343.         a[i] = rand() % MM;  
344.     printf("随机数序列：");  
345.     for (i = 0; i < NN; i++)  
346.         printf("%d,",a[i]);  
347.     printf("\n");  
348.     printf("随机数逆序：");  
349.     for (i = 0; i < NN; i++)  
350.         InsertFirstList(&p, a[i]);  //将a[i]倒序插入单链表  
351.     TraverseList(p);                //遍历  
352.     printf("单链表长度：%d\n", SizeList(p)); //输出单链表长度  
353.     for (h = p; h != NULL; h = h->next)      //每个元素循环与后面的元素进行比较，删除重复数  
354.         while (DeleteValueList(&(h->next), h->data));  
355.     printf("去除重复数：");  
356.     TraverseList(p);                         //遍历  
357.     printf("单链表长度：%d\n", SizeList(p)); //输出单链表长度  
358.     h = NULL;  
359.     for (s = p; s != NULL; s = s->next)//将上面的单链表的值依次插入新的一个空单链表，每步插入后都有序  
360.         InsertOrderList(&h, s->data);  
361.     printf("有序表序列：");  
362.     TraverseList(h);                   //遍历  
363.     ClearList(&p);                     //清除单链表  
364. }  

运行结果：

4、双链表

在每个结点中除包含有数值域外，设置有两个指针域，分别用以指向其前驱结点和后继结点，这样构成的链接表被称为线性双向链接表，简称双向链接表或双链表。

双链表存储结构示意图：

双链表的结点类型：

[cpp]  view plain  copy

1. struct dNode  
2. {  
3.     ElemType data;  
4.     struct dNode* left;    //左指针域  
5.     struct dNode* right;  // 右指针域  
6. };  

双链表的插入：若在双链表中p结点之后插入一个q结点

[cpp]  view plain  copy

1. q->right = p->right;  
2. if (p->right)    //p结点有后继结点  
3.     p->right->left = q;  
4. q->left = p;  
5. p->right = q;  

双链表的删除：若要删除双链表中p指针所指向的结点，并假设p结点前后都存在结点

[cpp]  view plain  copy

1. p->left->right = p->right;  
2. p->right->left = p->left;  

5、循环链表

在单链表中，若让表尾结点的指针域指向表头结点，在双链表中，若让表尾结点的右指针域指向表头结点，而让表头结点的左指针域指向表尾结点，就构成了循环链表。

6.代表头附加结点的线性链表

在线性表的链接存储中，为了方便在表头插入和删除结点，使得与在其他地方所做的操作相同，需要在表头结点的前面增加一个结点，把它称为表头附加结点或头结点。