Data structure Basics (1)--array C language implementation--dynamic memory allocation

Data structure Basics (1)--array C language implementation--dynamic memory allocation

Basic idea: An array is the most commonly used data structure that is stored continuously in memory, can be statically initialized (int a[2]={1,2}), and can be dynamically initialized with malloc ().

The difficulty is that when the array is deleted or inserted, the coordinates of the element are not determined. Law:

1. If you want to insert an element in the array pos position (should be moved from the back)

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

PBASE[I]=PBASE[I-1];

2. Delete the element at POS position of the array

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

PBASE[I-2]=PBASE[I-1];

Dynamically allocating memory using malloc and assigning the return value to the shaping pointer

int *pbase= (int *) malloc (sizeof (int) *len);//Allocate 4*len byte-length memory

This is pbase can point to the first element in the array and can be used as an array variable name.

Advantages and disadvantages of arrays:

Advantages:

Fast access speed O (1) The memory location can be found directly according to the subscript

Disadvantages:

The length of the array must be known beforehand

Insert Delete element is slow

Space is usually limited.

Chunks of contiguous blocks of memory are required

Insertion of deleted elements is inefficient

[CPP]View Plain Copy

2. #include <stdio.h>
4. #include <malloc.h>
6. #include <stdbool.h>
8. struct arr{
10. The maximum number of elements that an int len;//array can access
12. int cnu;//The current number of elements in the array
14. int * pbase;//stores pointers to arrays
16. };
22. /**
24. * Initialize Array
26. */
28. void Init_array (struct ARR * Parray,int len) {
30. parray->pbase= (int *) malloc (sizeof (int) *len);//Allocate 4*len byte-length memory
32. if (null== parray->pbase)//Determine if memory allocation failed
34. {
36. printf ("Dynamically allocating memory failed \ n");
38. Exit (-1);
40. }else{
42. parray->len=len;
44. parray->cnu=0;
46. }
48. return;
50. }
54. /**
56. * Determine if the array is empty, address the memory 4 bytes, transfer structure variables need to be copied, 12 bytes
58. */
60. BOOL IsEmpty (struct ARR * parray) {
62. if (0==PARRAY->CNU)
64. {
66. return true;
68. }else{
70. return false;
72. }
74. }
78. /**
80. * * Determine if the array is full
82. */
84. BOOL Isfull (struct ARR * parray)
86. {
88. if (PARRAY->LEN==PARRAY->CNU)
90. {
94. return true;
96. }else {
98. return false;
100. }
104. }
106. /**
108. * Display array Contents
110. */
112. void Show_array (struct ARR * parray) {
114. if (IsEmpty (Parray))
116. printf ("The array is empty! \ n ");
118. else{
120. int i;
122. for (i=0; i<parray->cnu;i++)
124. {
126. printf ("%d \ n", Parray->pbase[i]);
128. }
130. printf ("------------------------------------\ n");
132. }
134. }
138. /**
140. * * Append an element to an array
142. */
144. BOOL Append (struct ARR * Parray,int val) {
146. if (Isfull (Parray))
148. {
150. printf ("The array is full!" \ n ");
152. return false;
154. }else{
156. parray->pbase[parray->cnu]=val;
158. parray->cnu++;
162. }
164. }
170. /**
172. * * Inserts an element into an array, POS is the number of positions in a group, pos=3 is inserting an element into the a[2]
174. */
178. BOOL Insert (struct ARR * parray,int pos,int val)
180. {
182. if (pos<1| | POS>PARRAY->LEN+1)//inserted position cannot be less than 1, and cannot be more than the last element sophomore
184. {
186. printf ("An illegal entry in the inserted position \ n");
188. return false;
190. }
192. if (Isfull (Parray))
194. {
196. printf ("The array is full, the insertion failed!") \ n ");
198. return false;
200. }
202. int i;
204. Loop moves the array that starts the POS position back
206. for (i=parray->cnu;i>=pos;i--)
208. The moving range is from the first POS to the end of CNU
210. {
212. parray->pbase[i]=parray->pbase[i-1];
214. /**
216. If I represents the position of the element to move, from the beginning. Right is i-1, if left, left is i-2, right shift, left is I
218. */
220. }
228. parray->pbase[pos-1]=val;
230. parray->cnu++;
232. parray->len++;
234. return true;
236. }
238. /**
240. * * Delete the first POS element in the array while returning the value of the deleted element
242. */
246. BOOL Delete (struct ARR * parray,int Pos,int * val)
248. {
250. if (pos<1| | POS>PARRAY->CNU)
252. {
254. printf ("Delete failed, location not valid \ n");
256. return false;
258. }
260. int i;
262. *val=parray->pbase[pos-1];
264. for (i=pos+1;i<=parray->cnu;i++)
266. {
268. Moving units are from pos+1 to CNU
270. parray->pbase[i-2]=parray->pbase[i-1];
274. }
276. parray->cnu--;
278. return true;
282. }
286. /**
288. * * Array Inversion
290. */
294. bool Inverse (struct ARR * parray)
296. {
298. if (IsEmpty (Parray))
300. {
302. printf ("Inversion fails, factor group is empty");
304. return false;
306. }
310. int i=0;
312. int j=parray->cnu-1;
316. int temp;
318. while (I<J)
320. {
322. temp=parray->pbase[i];
324. parray->pbase[i]= parray->pbase[j];
326. parray->pbase[j]=temp;
328. i++;
330. j--;
332. }
334. return true;
338. }
340. int main ()
342. {
344. struct ARR arr;
346. Init_array (&arr,6);//The address of the struct is used as an argument in order to modify the value in the struct, and if a struct variable is passed, it will be copied without changing the value
348. Append (&arr,1);
350. Append (&arr,2);
352. Append (&arr,3);
354. Append (&arr,4);
356. Show_array (&arr);
358. Insert (&arr,2,88);
360. Show_array (&arr);
362. int Val;
364. Delete (&arr,1,&val);
366. Show_array (&arr);
368. printf ("Removed%d\n", Val);
370. Inverse (&arr);
372. Show_array (&arr);
374. return 0;
376. }

Data structure Basics (1)--array C language implementation--dynamic memory allocation