顺序表的操作完整代码（c语言）

Julia999

1. #include<stdio.h>
   
2. #include<malloc.h>
   
3. #include<stdlib.h>
   
4. 
   
5. #define maxsize 100  //定义顺序表的最大储存个数是100
   
6. typedef int ElemType;
   
7. 
   
8. //定义顺序表的结构，并用ElemType的数组来储存数组元素，并且元素的个数为length
   
9. typedef struct
   
10. {
    
11.         ElemType data[maxsize];
    
12.         int length;  
    
13. }List;
    
14. 
    
15. //建立顺序表(定义一个函数建立顺序表，将数组a的元素给顺序表）
    
16. void creatList(List*& L, ElemType a[], int n)
    
17. {
    
18.         int length = 0;
    
19.         L = (List*)malloc(sizeof(List));
    
20.         for (int i = 0; i < n; i++)
    
21.         {
    
22.                 L->data[i] = a[i];
    
23.                 length += 1;
    
24.         }
    
25.         L->length = length;
    
26. }
    
27. 
    
28. //初始化顺序表
    
29. void initList(List*& L)
    
30. {
    
31.         L = (List*)malloc(sizeof(List));  //给顺序表L分配空间
    
32.         L->length = 0;   //定义L的长度length为0
    
33. }
    
34. 
    
35. //销毁顺序表
    
36. void destroyList(List*& L)
    
37. {
    
38.         free(L);  //释放顺序表L的空间  
    
39. }
    
40. 
    
41. //判断顺序表是否为空
    
42. bool listEmpty(List*& L)
    
43. {
    
44.         return(L->length == 0);  //若为空，返回true，如果不为空，返回false
    
45. }
    
46. 
    
47. //求线性表的长度
    
48. int ListLength(List*& L)
    
49. {
    
50.         return (L->length);
    
51. }
    
52. 
    
53. //输出线性表
    
54. void outputList(List*& L)
    
55. {
    
56.         if (listEmpty(L))  //如果顺序表为空
    
57.         {
    
58.                 printf("顺序表为空！\n");
    
59.                 return;
    
60.         }
    
61.         else  //否则逐个输出元素
    
62.         {
    
63.                 for (int i = 0; i < L->length; i++)
    
64.                 {
    
65.                         printf("%d ", L->data[i]);
    
66.                 }
    
67.                 printf("\n");
    
68.         }
    
69. }
    
70. 
    
71. //取顺序表中某个位置的元素
    
72. void GetElem(List*& L, int i, int& e)  //在线性表L中取第i位置的值并给e
    
73. {
    
74.         if (i < 0 || i > L->length || L->length == 0)  //如果i不合法或者L为空
    
75.         {
    
76.                 printf("顺序表为空！\n");
    
77.                 return;
    
78.         }
    
79.         else
    
80.         {
    
81.                 e = L->data[i-1];
    
82.         }
    
83. }
    
84. 
    
85. //判断顺序表中是否存在某个元素，并返回所在位置
    
86. void LocateElem(List*& L, ElemType e)
    
87. {
    
88.         for (int i = 0; i < L->length; i++)
    
89.         {
    
90.                 if (e == L->data[i])
    
91.                 {
    
92.                         printf("位置在%d处\n", i + 1);
    
93.                         return;
    
94.                 }
    
95.         }       
    
96. }
    
97. 
    
98. //插入元素(在线性表的第i个位置插入元素e）
    
99. void ListInsert(List*& L, int i, ElemType e)
    
100. {
     
101.         if (i<0 || i>L->length + 1)  //如果i不合法
     
102.         {
     
103.                 printf("输入位置不合法！\n");
     
104.                 return;
     
105.         }
     
106.         else
     
107.         {
     
108.                 for (int j = L->length-1; j >= i-1; j--)
     
109.                 {
     
110.                         L->data[j + 1] = L->data[j];
     
111.                 }
     
112.                 L->data[i - 1] = e;
     
113.                 L->length += 1;
     
114.         }
     
115. }
     
116. 
     
117. 
     
118. //删除元素
     
119. void ListDelete(List*& L, int i)  //在顺序表中删除第i个元素
     
120. {
     
121.         if (i<0 || i>L->length)  
     
122.         {
     
123.                 printf("删除位置不合法！\n");
     
124.                 return;
     
125.         }
     
126.         else
     
127.         {
     
128.                 for (int j = i-1; j < L->length; j++)
     
129.                 {
     
130.                         L->data[j] = L->data[j + 1];
     
131.                 }
     
132.                 L->length -= 1;
     
133.         }
     
134. }
     
135. 
     
136. int main()
     
137. {
     
138.         List *L;
     
139.         int e=99;
     
140.         int a[4] = { 0,1,2,3 };
     
141.         creatList(L, a, 4);
     
142.         //initList(L);
     
143.         outputList(L);
     
144.         printf("该顺序表的长度是%d\n", ListLength(L));
     
145.         //取线性表某个位置的值
     
146.         GetElem(L, 1, e);
     
147.         printf("取出来的值是：%d\n", e);
     
148. 
     
149.         //判断是否有某个元素
     
150.         LocateElem(L, 1);
     
151. 
     
152.         //插入
     
153.         ListInsert(L, 10, 100);
     
154.         ListInsert(L, 2, 100);
     
155.         outputList(L);
     
156. 
     
157.         //删除
     
158.         ListDelete(L, 1);
     
159.         outputList(L);
     
160. 
     
161.         //销毁
     
162.         destroyList(L);
     
163.         outputList(L);
     
164.        
     
165.         return 0;
     
166. }

复制代码