数组的各种操作

Julia999

线性结构【把所有的结点都用一根直线穿起来】
连续存储【数组】
      1.什么叫数组
            元素类型相同，大小相等
      2.数组的优缺点

1. #include<stdio.h>
   
2. #include<malloc.h>
   
3. #include<stdlib.h>  //包含exit()函数
   
4. //定义了一个数据类型，该数据类型的名字叫做struct Arr,
   
5. struct Arr
   
6. {
   
7.         int *pBase;  //存储的是数组第一个元素的地址
   
8.         int len;     //数组所能容纳的最大元素的个数、
   
9.         int cnt;     //当前数组有效元素的个数
   
10.        
    
11. };
    
12. 
    
13. void init_arr(struct Arr *pArr,int length)
    
14. {
    
15.         (*pArr).len=99;
    
16.         pArr->pBase=(int *)malloc(sizeof(int)*length);
    
17.         if(NULL==pArr->pBase)
    
18.         {
    
19.                 printf("动态内存分配失败！");
    
20.                 exit(-1);  //终止整个程序
    
21.         }
    
22.         else
    
23.         {
    
24.                 pArr->len=length;
    
25.                 pArr->cnt=0;
    
26.         }
    
27.     return;
    
28. }
    
29. 
    
30. bool append_arr(struct Arr *pArr,int val)  //追加
    
31. {
    
32.         if(if_full(pArr))
    
33.                 return false;
    
34.         pArr->pBase[pArr->cnt]=val;
    
35.         (pArr->cnt)++;
    
36.         return true;
    
37.          
    
38. }
    
39. 
    
40. bool insert_arr(struct Arr *pArr,int pos,int val)  //pos 的值从1开始
    
41. {
    
42.         if(is_full())
    
43.                 return false;
    
44. 
    
45.         if(pos<1||pos>pArr->cnt+1)  
    
46.                 return false;
    
47. 
    
48.         int i;
    
49.         for(i=pArr->cnt;i<=pos-1;--i)
    
50.         {
    
51.                 pArr->pBase[i+1]=pArr->pBase[i];
    
52.         }
    
53.         pArr->pBase[pos-1]=val;
    
54.         pArr->cnt++;
    
55.         return true;
    
56. 
    
57. }
    
58. 
    
59. bool delete_arr(struct Arr *pArr,int pos,int *pVal)
    
60. {
    
61.         if(is_empty(pArr))
    
62.                 return false;
    
63.         if(pos<1||pos>pArr->cnt)
    
64.                 return false;
    
65.         *pVal=pArr->pBase[pos-1];
    
66.         for(int i=pos;i<pArr->cnt;++i)
    
67.                 pArr->pBase[i-1]=pArr->pBase[i];
    
68.         pArr->cnt--;
    
69.         return true;
    
70. 
    
71. }
    
72. 
    
73. 
    
74. bool is_empty(struct Arr *pArr)
    
75. {
    
76.         if(pArr->cnt==0)
    
77.                 return true;
    
78.         else
    
79.         {
    
80.                 return false;
    
81.         }
    
82. }
    
83. 
    
84. bool is_full(struct Arr *pArr)
    
85. {
    
86.         if(pArr->cnt==pArr->len)
    
87.         {
    
88.                 return true;
    
89.         }
    
90.         else
    
91.                 return false;
    
92. }
    
93. 
    
94. void sort_arr(struct Arr *pArr)
    
95. {
    
96.         int i,j,t;
    
97.         for(i=0;i<pArr->cnt;++i)
    
98.         {
    
99.                 for(j=i+1;j<pArr->cnt;++j)
    
100.                 {
     
101.                         t=pArr->pBase[i];
     
102.                     pArr->pBase[i]=pArr->pBase[j];
     
103.                     pArr->pBase[j]=t;
     
104.                 }
     
105.         }
     
106. 
     
107. }
     
108. 
     
109. void show_arr(struct Arr *pArr)
     
110. {
     
111.         if(is_empty(pArr))
     
112.         {
     
113.                 printf("数组为空！\n");
     
114.         }
     
115.         for(int i=0;i<pArr->len;i++)
     
116.         {
     
117.                 printf("%d  ",pArr->pBase[i]);
     
118. 
     
119.         }
     
120.         printf("\n");
     
121. }
     
122. 
     
123. void inversion_arr(struct Arr *pArr)
     
124. {
     
125.         int i=0;
     
126.         int j=pArr->cnt-1;
     
127.         int t;
     
128.         while(i<j)
     
129.         {
     
130.                 t=pArr->pBase[i];
     
131.                 pArr->pBase[i]=pArr->pBase[j];
     
132.                 pArr->pBase[j]=t;
     
133.                 ++i;
     
134.                 --j;
     
135. 
     
136.         }
     
137.         return;
     
138. 
     
139. }
     
140. 
     
141. int main()
     
142. {
     
143.         struct Arr arr;  //只是定义了一个变量，但是没有初始化，所以里面的元素都还是垃圾数字
     
144.         //init_arr(arr);  //这样传进去之后，array和arr并不是同一个，函数只能改变函数内部array中的数值。但arr并没有初始化
     
145.         int val;
     
146.         init_arr(&arr,6);
     
147.         show_arr(&arr);
     
148.         append_arr(&arr,1);
     
149.         append_arr(&arr,2);
     
150.         append_arr(&arr,3);
     
151.         append_arr(&arr,4);
     
152.         append_arr(&arr,5);
     
153.         insert_arr(&arr,1,99);
     
154.         if(delete_arr(&arr,1,&val))
     
155.         {
     
156.                 printf("删除成功！\n");
     
157.                 printf("您删除的元素是:%d\n",val)
     
158.         }
     
159.         else
     
160.                 printf("删除失败！\n");
     
161. 
     
162.         show_arr(&arr);
     
163.         inversion_arr(&arr);
     
164.     show_arr(&arr);
     
165.         sort_arr(&arr);
     
166.     show_arr(&arr);
     
167. 
     
168.         return 0;
     
169. }

复制代码

离散存储【链表】
线性结构的两种常见的应用之一：栈
线性结构的两种常见的应用之二：队列