数据结构---顺序表实现(源码)

复习一下数据结构，希望以后每周能坚持发一章。

第一章   顺序表

1. /*****************************SqList**********************************
2. Date:2008.10.22
3. Author:ZORO
4. WebSite:http://blog.youkuaiyun.com/sevenhu
6. ======================================================================
8. 参考资料：
9. BOOK:数据结构(C语言版)     严蔚敏     清华大学出版社
10. Page:19
12. ======================================================================
13. ADT SqList  {
14.     InitList(&L)
15.     DestroyList(&L)
16.     ListPush(&L,i)
17.     ClearList(&L)
18.     ListEmpty(L)
19.     ListLength(L)
20.     GetElem(L,i,&e)
21.     LocateElem(L,e)
22.     PriorElem(L,cur_e,&pre_e)
23.     NextElem(L,cur_e,&next_e)
24.     ListInsert(&L, i, e)
25.     ListDelete(&L, i, e)
26.     ListTraverse(L)
27. }ADT SqList
28. ======================================================================
29. note:VC++ 6.0测试通过。
30. *********************************************************************/
33. #include <iostream>
35. #define     OK                  1
36. #define     FALSE               0
37. #define     ERROR               0
38. #define     OVERFLOW            -1
39. #define     NULL                0
42. #define     LIST_INIT_SIZE      100     //顺序表存储空间的初始分配量
43. #define     LISTINCREMENT       10      //顺序表存储空间的分配增量
46. using namespace std;
47. typedef int Status;
48. typedef bool BOOL;
50. typedef struct SQ{
51.     int * elem;
52.     int length;                         //顺序表当前大小
53.     int listsize;                       //顺序表容量
54. } SqList;
56. Status InitList(SqList &L)
57. {
58.     //构造表
59.     L.elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));
60.     
61.     if (!L.elem)  {                     //空间分配失败
62.         return OVERFLOW;
63.     }
64.     
65.     L.length = 0;                       //初始化长度为0
66.     L.listsize = LIST_INIT_SIZE;        //初始存储容量
67.     return OK;
68. } //InitList_Sq
70. Status ListPush(SqList &L, int i)
71. {
72.     //增加元素
73.     if (!L.elem)  {
74.         return ERROR;                   //表不存在
75.     }
77.     if (L.length == L.listsize)  {      //空间不足，重新分配
78.         L.elem = (int *)realloc(L.elem,sizeof(int) * (LISTINCREMENT + L.listsize));
79.         if (!L.elem)  {
80.             return OVERFLOW;            //分配失败
81.         }
82.         L.listsize += LISTINCREMENT;    //新空间容量
83.     }
85.     L.elem [L.length] = i;
86.     ++L.length;
88.     return OK;
89. }
92. Status ListInsert(SqList &L, int i, int e)
93. {
94.     //在顺序表L中第i个位置前插入元素e
95.     if (!L.elem)  {
96.         return ERROR;                   //表不存在
97.     }
98.     
99.     if (i > L.length - 1 || i < 1)  {   //i值不合法
100.         return ERROR;
101.     }
103.     if (L.length == L.listsize)  {
104.         int * newbase;                  //空间不足，重新分配
105.         newbase = (int *)realloc(L.elem,sizeof(int) * (LISTINCREMENT + L.listsize));
106.         L.elem = newbase;
108.         if (!L.elem)  {
109.             return OVERFLOW;            //分配失败
110.         }
111.         L.listsize += LISTINCREMENT;    //新空间容量
112.     }
114.     int * q = &L.elem[i-1];             //标记插入位置
116.     for (int * p = &L.elem[L.length-1]; p >= q; --p)  {
117.         *(p+1) = *p;                    //插入位置及其后元素后移一位
118.     }
120.     *q = e;                             //插入e
121.     ++L.length;                         //长度加1
122.     q = p = NULL;
123.     return OK;
124. }//ListInsert
126. Status ListDelete(SqList &L, int i, int &e)
127. {
128.     //在顺序表L中删除第i个值并用e返回这个值
129.     if (!L.elem)  {
130.         return ERROR;                   //表不存在
131.     }
132.     
133.     if (i < 1 || i > L.length - 1)  {
134.         return ERROR;                   //i值不合法
135.     }
137.     int *p = &L.elem[i-1];              //i位置的元素地址
138.     e = *p;                             
139.     int *q = L.elem + L.length - 1;     //L的最后一个元素地址
140.     for (++p ; p <= q; ++p)  {
141.         *(p-1) = *p;                    //把i位置后的元素向前移一位
142.     }
144.     --L.length;                         //L的长度减1
146.     return OK;
147. }//ListDelete
149. Status DestroyList(SqList &L)
150. {
151.     //销毁L表
152.     if (!L.elem)  {
153.         return ERROR;                   //表不存在
154.     }
156.     free(L.elem);                       //释放内存
157.     return OK;
158. }//DestroyList
160. Status ClearList(SqList &L)
161. {
162.     //清空表
163.     if (!L.elem)  {
164.         return ERROR;                   //表不存在
165.     }
167.     L.length = 0;                       //表长清零
168.     return OK;
169. }//ClearList
171. BOOL ListEmpty(SqList L)
172. {
173.     //判断表是否为空
174.     if (!L.elem)  {
175.         return ERROR;                   //表不存在
176.     }
178.     if (L.length == 0)  {
179.         return true;
180.     }
181.     
182.     return false;
183. }//ListEmpty
185. int ListLength(SqList L)
186. {
187.     //表元素的个数
188.     if (!L.elem)  {
189.         return ERROR;                   //表不存在
190.     }
192.     return L.length;
193. }//ListLength
195. Status GetElem(SqList L, int i, int &e)
196. {
197.     //用e返回L表中第i个元素
198.     if (!L.elem)  {
199.         return ERROR;                   //表不存在
200.     }
202.     if (i < 1 || i > L.length - 1)  {
203.         return ERROR;                   //i值不合法
204.     }
206.     int * q = L.elem ;
207.     e = *(q + i -1);                    //把第i个元素给e
208.     
209.     return OK;
210. }//GetElem
213. int LocateElem(SqList L, int e)
214. {
215.     //返回与e相等的第一个元素的位置
216.     if (!L.elem)  {
217.         return ERROR;                   //表不存在
218.     }
220.     int i = 1;
221.     int * p = L.elem ;
222.     while (i < L.length && *p++ != e ) {//查找与e相等的值的位置
223.         ++i;
224.     }
225.     
226.     if (i <= L.length )  {
227.         return i;
228.     }
230.     return 0;
231. }
233. Status PriorElem(SqList L, int cur_e, int & pre_e)
234. {
235.     //若cur_e是L的数据元素，且不是第一个，用pre_e返回它的前驱，否则操作失败，pre_e无定义
236.     if (!L.elem)  {
237.         return ERROR;                   //表不存在
238.     }
239.     int i = LocateElem(L,cur_e);
240.     if (i == 1)  {
241.         return FALSE;
242.     }
243.     else if(i == 0)  {
244.         return FALSE;
245.     }
247.     pre_e = L.elem [i-2];               //前驱值给pre_e
249.     return OK;
250. }//PriorElem
252. Status NextElem(SqList L, int cur_e, int & next_e)
253. {
254.     //若cur_e是L的数据元素，且不是最后一个，用next_e返回它的后继，否则操作失败，next_e无定义
255.     if (!L.elem)  {
256.         return ERROR;                   //表不存在
257.     }
258.     int i = LocateElem(L,cur_e);
260.     if (i == L.length )  {
261.         return FALSE;
262.     }
263.     else if (i == 0)  {
264.         return FALSE;
265.     }
267.     next_e = L.elem [i];                //后继值给next_e
269.     return OK;
270. }//NextElem
272. Status ListTraverse(SqList L)
273. {
274.     //遍历L表
275.     if (!L.elem)  {
276.         return ERROR;                   //表不存在
277.     }
279.     for (int i = 0 ; i < L.length ; ++i)  {
280.         cout << L.elem[i] << " ";       //输出
281.     }
282.     cout << endl;
284.     return OK;
285. }//ListTraverse
288. int main()
289. {
290.     SqList L;
291.     if (InitList(L) == OK)  {
292.         cout << "成功创建顺序表!" << endl;
293.     }
294.     else  {
295.         cout << "创建顺序表失败!" << endl;
296.         return FALSE;
297.     }
299.     for (int i = 0; i < 15; ++i)  {
300.         if (ListPush(L,i) != OK)  {
301.             cout << "录入数据失败!" << endl;
302.             return FALSE;
303.         }
304.     }
306.     cout << "成功录入数据!" << endl;
309.     cout << "遍历顺序表!" << endl;
310.     ListTraverse(L);
312.     cout << "共" << ListLength(L) << "个元素" << endl;
314.     cout << "清空顺序表!" << endl;
315.     ClearList(L);
317.     cout << "是否是空表?" << endl;   
318.     cout << ListEmpty(L) << endl;
320.     for (i = 15; i > 0; --i)  {
321.         if (ListPush(L,i) != OK)  {
322.             cout << "录入数据失败!" << endl;
323.             return FALSE;
324.         }
325.     }
327.     cout << "成功录入数据!" << endl;
328.     cout << "遍历顺序表!" << endl;
329.     ListTraverse(L);
331.     int e;
332.     GetElem(L,6,e);
334.     cout << "第6个元素的值:"<< e << endl; 
336.     PriorElem(L,7,e);
337.     cout << "元素7的前驱元素:" << e << endl;
339.     NextElem(L,7,e);
340.     cout << "元素7的后继元素:" << e << endl;
342.     cout << "在第4个位置插入元素100" << endl;
343.     ListInsert(L,4,100);
344.     ListTraverse(L);
346.     cout << "删除第6个位置的元素" << endl;
347.     ListDelete(L,6,e);
348.     cout << "删除的元素为:" << e << endl;
349.     ListTraverse(L);
351.     cout << "元素4的位置是" << LocateElem(L,4) << endl;
352.     
353.     if (DestroyList(L)  == OK)  {
354.         cout << "成功销毁顺序表!" << endl;
355.         return 0;
356.     }
357.     else
358.     {
359.         cout << "销毁顺序表失败!" << endl;
360.         return FALSE;
361.     }
362. }