数据结构基础（1）--数组C语言实现--动态内存分配（跟风追逐，加强突击）

数据结构基础（1）--数组C语言实现--动态内存分配http://blog.youkuaiyun.com/davidluo001/article/details/46447817

基本思想：数组是最常用的数据结构，在内存中连续存储，可以静态初始化（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) 可以直接根据下标找到内存位置

            缺点：

                事先必须知道数组的长度

                插入删除元素很慢

                空间通常是有限制的

                需要大块连续的内存块

                插入删除元素的效率很低

[cpp]  view plain  copy

 print ?

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. };  
9.   
10.   
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. }  
26.   
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. }  
38.   
39. /** 
40. **判断数组是否满了 
41. */  
42. bool isfull(struct Arr * pArray)  
43. {  
44.   if(pArray->len==pArray->cnu)  
45.   {  
46.   
47.       return true;  
48.   }else {  
49.   return false;  
50.   }  
51.   
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. }  
68.   
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++;  
80.   
81. }  
82. }  
83.   
84.   
85. /** 
86. **向数组中插入元素,pos为数组中第几个位置，pos=3就是向a[2]插入元素 
87. */  
88.   
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.    }  
111.   
112.   
113.   
114.        pArray->pBase[pos-1]=val;  
115.        pArray->cnu++;  
116.        pArray->len++;  
117.        return true;  
118. }  
119. /** 
120. **删除数组中的第pos个元素，同时返回删除的元素的值 
121. */  
122.   
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];  
136.   
137.      }  
138.       pArray->cnu--;  
139.       return true;  
140.   
141. }  
142.   
143. /** 
144. **数组倒置 
145. */  
146.   
147. bool inverse(struct Arr * pArray)  
148. {  
149. if(isempty(pArray))  
150. {  
151.     printf("倒置失败，因数组为空");  
152.     return false;  
153. }  
154.   
155. int i=0;  
156. int j=pArray->cnu-1;  
157.   
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;  
168.   
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. }