數據結構基礎（1）--數組C語言實現--動態內存分配

基本思想：數組是最常用的數據結構，在內存中連續存儲，可以靜態初始化（int a[2]={1,2}），可以動態初始化 malloc（）。

難點就是數組在刪除或者插入元素的時候，要移動元素的坐標不好確定。規律：

1.如果要在數組中第pos個位置插入一個元素（應該從後面開始移動）

for( i=cnu;i>=pos;i--)

pBase[i]=pBase[i-1];

2.刪除數組第pos位置的元素

for(i=pos+1;i<=cnu;i--)

pBase[i-2]=pBase[i-1];

使用malloc動態分配內存並將返回值賦給整形指針

int *pBase=(int *)malloc(sizeof(int)*len);//分配4*len字節長度的內存

這是pBase可以指向數組中的第一個元素，可以作為數組變量名稱使用。

數組的優缺點：

優點：

存取速度快 o(1) 可以直接根據下標找到內存位置

缺點：

事先必須知道數組的長度

插入刪除元素很慢

空間通常是有限制的

需要大塊連續的內存塊

插入刪除元素的效率很低

1. #include<stdio.h>
2. #include<malloc.h>
3. #include<stdbool.h>
4. struct Arr{
5. int len;//數組能存取的最大元素個數
6. int cnu;//數組中當前元素個數
7. int * pBase;//存儲指向數組的指針
8. };
11. /**
12. *初始化數組
13. */
14. void init_array(struct Arr * pArray,int len){
15. pArray->pBase=(int *)malloc(sizeof(int)*len);//分配4*len字節長度的內存
16. if(NULL== pArray->pBase)//判斷內存是否分配失敗
17. {
18. printf("動態分配內存失敗\n");
19. // exit(-1);
20. }else{
21. pArray->len=len;
22. pArray->cnu=0;
23. }
24. return ;
25. }
27. /**
28. *判斷數組是否為空，傳地址省內存4字節，傳結構體變量需要進行拷貝，12字節
29. */
30. bool isempty(struct Arr * pArray){
31. if(0==pArray->cnu)
32. {
33. return true;
34. }else{
35. return false;
36. }
37. }
39. /**
40. **判斷數組是否滿了
41. */
42. bool isfull(struct Arr * pArray)
43. {
44. if(pArray->len==pArray->cnu)
45. {
47. return true;
48. }else {
49. return false;
50. }
52. }
53. /**
54. *顯示數組內容
55. */
56. void show_array(struct Arr * pArray){
57. if(isempty(pArray))
58. printf("數組為空！\n");
59. else{
60. int i;
61. for( i=0; i<pArray->cnu;i++)
62. {
63. printf("%d \n",pArray->pBase[i]);
64. }
65. printf("------------------------------------\n");
66. }
67. }
69. /**
70. **向數組追加元素
71. */
72. bool append(struct Arr * pArray,int val){
73. if(isfull(pArray))
74. {
75. printf("數組已經滿了！\n");
76. return false;
77. }else{
78. pArray->pBase[pArray->cnu]=val;
79. pArray->cnu++;
81. }
82. }
85. /**
86. **向數組中插入元素,pos為數組中第幾個位置，pos=3就是向a[2]插入元素
87. */
89. bool insert(struct Arr * pArray,int pos,int val)
90. {
91. if(pos<1||pos>pArray->len+1)//插入的位置不能小於1，同時不能比最後一個元素大二
92. {
93. printf("插入的位置輸入的不合法\n");
94. return false;
95. }
96. if(isfull(pArray))
97. {
98. printf("數組已經滿了,插入失敗！\n");
99. return false;
100. }
101. int i;
102. //循環將pos位置開始的數組後移
103. for(i=pArray->cnu;i>=pos;i--)
104. //移動範圍是從第pos個到底cnu個
105. {
106. pArray->pBase[i]=pArray->pBase[i-1];
107. /**
108. 若以i表示要移動元素的位置，從一開始的。右邊都是i-1,若左移，左邊是i-2,右移，左邊是i
109. */
110. }
114. pArray->pBase[pos-1]=val;
115. pArray->cnu++;
116. pArray->len++;
117. return true;
118. }
119. /**
120. **刪除數組中的第pos個元素，同時返回刪除的元素的值
121. */
123. bool delete(struct Arr * pArray,int pos,int * val)
124. {
125. if(pos<1||pos>pArray->cnu)
126. {
127. printf("刪除失敗，位置不合法\n");
128. return false;
129. }
130. int i;
131. *val=pArray->pBase[pos-1];
132. for(i=pos+1;i<=pArray->cnu;i++)
133. {
134. //移動單位是從第pos+1個到cnu
135. pArray->pBase[i-2]=pArray->pBase[i-1];
137. }
138. pArray->cnu--;
139. return true;
141. }
143. /**
144. **數組倒置
145. */
147. bool inverse(struct Arr * pArray)
148. {
149. if(isempty(pArray))
150. {
151. printf("倒置失敗，因數組為空");
152. return false;
153. }
155. int i=0;
156. int j=pArray->cnu-1;
158. int temp;
159. while(i<j)
160. {
161. temp=pArray->pBase[i];
162. pArray->pBase[i]= pArray->pBase[j];
163. pArray->pBase[j]=temp;
164. i++;
165. j--;
166. }
167. return true;
169. }
170. int main()
171. {
172. struct Arr arr;
173. init_array(&arr,6);//將結構體的地址作為實參，這樣才能修改結構體中的值，如果傳的是結構體變量，那麽將進行拷貝，不會改變值
174. append(&arr,1);
175. append(&arr,2);
176. append(&arr,3);
177. append(&arr,4);
178. show_array(&arr);
179. insert(&arr,2,88);
180. show_array(&arr);
181. int val;
182. delete(&arr,1,&val);
183. show_array(&arr);
184. printf("刪除了 %d\n",val);
185. inverse(&arr);
186. show_array(&arr);
187. return 0;
188. }

數據結構基礎（1）--數組C語言實現--動態內存分配