C语言动态顺序表源程序

最近在学习stm32的时候发现自己的c语言基础还停留在c51的水平，因此做一些练习提高自己的c语言水平。
我参考了 《妙趣横生的算法-c语言实现》这本书，建议大家从书 店入手

1. #include <stdio.h>
   
2. 
   
3. #include <mallco.h>              // 使用malloc函数要包含这个文件
   
4. #include <assert.h>
   
5. 
   
6. 
   
7. #define INIT_CAPACITY 10  // 初始化时分配的容量
   
8. 
   
9. 
   
10. typedef struct seqlist{
    
11.     int *array;        // 存储空间的基地址
    
12.     int size;          // 有效元素个数
    
13.     int capacity;      // 当前分配的存储容量
    
14. }SEQLIST;
    
15. 
    
16. 
    
17. void seqlist_init(SEQLIST *list);          //初始化顺序表
    
18. void check_capacity(SEQLIST *list);        // 检查是否满
    
19. 
    
20. void push_front(SEQLIST *list, int value);  // 在顺序表前头部插入元素
    
21. void push_back(SEQLIST *list, int value);   // 在顺序表尾部插入元素
    
22. void insert_list(SEQLIST *list, int pos, int value);        // 在pos这个位置插入元素
    
23. 
    
24. void pop_front(SEQLIST *list);              // 删除顺序表第一个元素
    
25. void pop_back(SEQLIST *list);               // 删除顺序表最后一个元素
    
26. 
    
27. void list_printf(SEQLIST *list);            // 遍历顺序表
    
28. void destroy_list(SEQLIST *list);           // 摧毁顺序表
    
29. void list_cleardata(SEQLIST *list);         // 清空顺序表的数据
    
30. 
    
31. 
    
32. int main(void)
    
33. {
    
34.     SEQLIST list;
    
35.    
    
36.     seqlist_init(&list);
    
37.     push_front(&list, 3);
    
38.     push_front(&list, 2);
    
39.     push_front(&list, 1);
    
40. //    list_printf(&list);
    
41.    
    
42.     push_back(&list, 3);
    
43.     push_back(&list, 2);
    
44.     push_back(&list, 1);
    
45.     pop_back(&list);
    
46.     pop_front(&list);
    
47.     insert_list(&list, 3, 4);
    
48.     list_printf(&list);
    
49.    
    
50.     return 0;
    
51. }
    
52. 
    
53. 
    
54. // 初始化顺序表
    
55. 
    
56. void seqlist_init(SEQLIST *list)
    
57. {
    
58.     assert(list);   // 断言：判断list是否为空
    
59.    
    
60.     list->array = (int *)malloc(INIT_CAPACITY * sizeof(int)); // 分配一断内存，容量为 INIT_CAPACITY个int的大小
    
61.     assert(list->array);               // 断言：判断aray是否为空
    
62.     list->size = 0;                    // 没有赋值之前有效元素个数为0
    
63.     list->capacity = INIT_CAPACITY;    // 容量
    
64. }
    
65. 
    
66. 
    
67. // 判断顺序表是否以满，如果满了，增加顺序表的容量
    
68. 
    
69. void check_capacity(SEQLIST *list)
    
70. {
    
71.     assert(list);    // 判断传入的指针是否为空
    
72.    
    
73.     if (list->size == list->capacity)
    
74.     {
    
75.          // 重新分配一块内存，但是之前的数据不变
    
76.         list->array = (int *)realloc(list->array, (2 * list->capacity * sizeof(int)));
    
77.         assert(list);            // 判断是否分配成功
    
78.         list->capacity *= 2;     // 容量翻倍
    
79.     }
    
80. }
    
81. 
    
82. 
    
83. // 在顺序表前插入数据   
    
84. void push_front(SEQLIST *list, int value)
    
85. {
    
86.     int i;
    
87.    
    
88.     assert(list);            // 判断传入的是否为空
    
89.     check_capacity(list);    // 在执行插入之前先判断顺序表是否以满，如果满了，增加顺序表的容量
    
90.    
    
91.     // 将所有元素向后移动一位
    
92.     for(i=list->size; i>=0; i--)
    
93.     {
    
94.         list->array[i] = list->array[i-1];
    
95.     }
    
96.     list->array[0] = value;  // 将插入的值赋给第一个元素
    
97.     list->size++;            // 有效元素个数 +1   
    
98. }
    
99. 
    
100. 
     
101. // 在顺序表尾部插入数据   
     
102. void push_back(SEQLIST *list, int value)
     
103. {
     
104.     assert(list);    // 判断传入的是否为空
     
105.    
     
106.     check_capacity(list);  // 在执行插入之前先判断顺序表是否以满，如果满了，增加顺序表的容量
     
107.    
     
108.     list->array[list->size] = value; // size记录了当前有效元素的个数，而数组从0开始，array[list->size]处在顺序表最后一个元素的位置+1
     
109.     list->size++;           // 插入后，有效元素个数+1
     
110. }
     
111. 
     
112. 
     
113. // 在顺序表第pos个位置插入数据   
     
114. void insert_list(SEQLIST *list, int pos, int value)
     
115. {
     
116.     int i;
     
117.    
     
118.     assert(list);  // 判断传入的指针是否为空
     
119.     if (pos > list->size+1 && pos < 0)
     
120.     {
     
121.         printf("非法操作！！\n");
     
122.         return;   
     
123.     }
     
124.    
     
125. 
     
126.     // 将第pos个位置之后的数据往后移动一位
     
127.     for (i=list->size; i>=pos; i--)
     
128.     {
     
129.         list->array[i] = list->array[i-1];   
     
130.     }
     
131.    
     
132.     list->array[pos-1] = value;
     
133.     list->size++;
     
134. }
     
135. 
     
136. 
     
137. // 删除头部数据
     
138. void pop_front(SEQLIST *list)
     
139. {
     
140.     int i = 0;
     
141.    
     
142.     assert(list);    // 判断传入的是否为空
     
143.    
     
144.     if (list->size == 1)
     
145.     {
     
146.         list->size = 0;
     
147.     }
     
148.     else
     
149.     {
     
150.         for (i=0; i<list->size; i++)
     
151.         {
     
152.             // 将后面的赋值给前面的，第0个元素的数据就不管了(第0个数据被覆盖)
     
153.             // 第1个元素的数据给第0个数据  第2个元素的数据给第1个数据 ...
     
154.             list->array[i] = list->array[i+1];  
     
155.         }
     
156.     }
     
157.     list->size--; // 有效数据的个数减1
     
158. }
     
159. 
     
160. // 尾部插入
     
161. void pop_back(SEQLIST *list)
     
162. {
     
163.     assert(list);
     
164.    
     
165.     if (list->size == 0)
     
166.     {
     
167.         return;   
     
168.     }
     
169.     else
     
170.     {
     
171.         list->size--;
     
172.     }
     
173. }
     
174. 
     
175. // 遍历数组，并打印
     
176. 
     
177. void list_printf(SEQLIST *list)
     
178. {
     
179.     int i;
     
180.    
     
181.     for (i=0; i<list->size; i++)
     
182.     {
     
183.         printf("%d  \n", list->array[i]);
     
184.     }
     
185. }
     
186.   // 摧毁顺序表
     
187. void destroy_list(SEQLIST *list)
     
188. {
     
189.     free(list->array);
     
190.    
     
191.     list->size = 0;
     
192.     list->capacity = 0;
     
193. }
     
194. 
     
195. // 清空顺序表的数据
     
196. void list_cleardata(SEQLIST *list)
     
197. {
     
198.     list->size = 0;
     
199. }

复制代码

厉害厉害，有点意思

厉害厉害，有点意思

提高一下自己 ,学习前辈的经验.谢谢.