2.2线性表的顺序存储和基本运算的实现

  1 #define _CRT_SECURE_NO_WARNINGS
  2 
  3 #include <stdio.h>
  4 #include <stdlib.h>
  5 
  6 //作为静态数组，无法变长，一旦分配内存，就固定了，不可以增加
  7 //外部的内存可以访问，但是外部内存可能被使用，也可能没有被使用
  8 //没有使用的情况下，越界偶尔会成功，还是可能被再次回收利用
  9 //已经使用，必然失败
 10 //a[n]等价于*(a+n);从数组名首地址开始，往下寻址，取出内容，数组不会检测越界
 11 //偶尔会成功，偶然的成功比必然的失败更加可怕，数组不可以越界
 12 
 13 main1()
 14 {
 15     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
 16 
 17     printf("%x\n", a);
 18 
 19     system("pause");
 20 }
 21 
 22 //静态数组，不可以处理较大的数据
 23 
 24 main2()
 25 {
 26     int b[1024 * 014 * 10];//默认数组在栈上，最大只能使用1MB
 27 
 28     printf("%x\n", b);
 29 
 30     system("pause");
 31 }
 32 
 33 main3()
 34 {
 35     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
 36     int i, j;
 37     int length = sizeof(a) / sizeof(int);
 38 
 39     for (i = 0;i < length;i++)
 40     {
 41         printf("%d\n", a[i]);
 42     }
 43 
 44     int num = 8;//要删除的元素
 45 
 46     if (num == a[9])//检测最后一个元素
 47     {
 48         length = length - 1;//删除一个元素，元素在末尾
 49     }
 50     else
 51     {
 52         for (i = 0;i < length - 1;i++)//检测最后一个之前
 53         {
 54             if (a[i] == num)
 55             {
 56                 for (j = i;j < length - 1;j++)//从删除的位置开始，到最后一个全部向前移动
 57                 {
 58                     a[j] = a[j + 1];//逐个向前移动赋值
 59                 }
 60                 length = length - 1;
 61                 break;
 62             }
 63         }
 64     }
 65 
 66     printf("尾部删除以后\n");
 67     for (i = 0;i < length;i++)
 68     {
 69         printf("%d\n", a[i]);
 70     }
 71 
 72     system("pause");
 73 
 74 }
 75 
 76 //查询方便
 77 main4()
 78 {
 79     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
 80     int i;
 81     int flag = 0;
 82     int length = sizeof(a) / sizeof(int);
 83 
 84     for (i = 0;i < length;i++)//逐个访问数组每个元素
 85     {
 86         if (a[i] == 7)//查询
 87         {
 88             flag = 1;
 89             break;
 90         }
 91     }
 92 
 93     if (flag == 1)
 94     {
 95         printf("找到");
 96     }
 97 
 98     system("pause");
 99 }
100 
101 //修改方便
102 main()
103 {
104     int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
105     int i;
106     int flag = 0;
107     int length = sizeof(a) / sizeof(int);
108 
109     for (i = 0;i < length;i++)//逐个访问数组每个元素
110     {
111         if (a[i] == 7)//查询
112         {
113             flag = 1;
114             a[i] = 9;
115             break;
116         }
117     }
118 
119     for (i = 0;i < length;i++)
120     {
121         printf("%d\n", a[i]);
122     }
123 
124     system("pause");
125 }

  1 #include <stdio.h>
  2 #include <stdlib.h>
  3 #include <stdbool.h>
  4 
  5 struct Arr
  6 {
  7     int *pBase;//存储的是数组第一个元素的地址
  8     int len;//数组所能容纳的最大元素的个数
  9     int cnt;//当前数组有效元素的个数
 10 };
 11 
 12 typedef struct Arr ARR;
 13 
 14 void init_arr(ARR *pArr, int length);//初始化
 15 bool append_arr(ARR *pArr, int val);//追加
 16 bool insert_arr(ARR *pArr, int pos, int val);//插入，pos值从1开始
 17 bool delete_arr(ARR *pArr, int pos, int * pVal);//删除元素
 18 int get();//暂无实现
 19 bool is_empty(ARR *pArr);//判断是否为空
 20 bool is_full(ARR *pArr);//判断是否已满
 21 void sort_arr(ARR *pArr);//排序
 22 void show_arr(ARR *pArr);//打印
 23 void inversion_arr(ARR *pArr);//逆序
 24 
 25 void main()
 26 {
 27     struct Arr arr;
 28     int val = 0;//保存删除以后的元素
 29     
 30     init_arr(&arr, 6);//初始化
 31     
 32     show_arr(&arr);//打印
 33 
 34     append_arr(&arr, 1);//追加
 35     append_arr(&arr, 2);
 36     append_arr(&arr, 3);
 37     append_arr(&arr, 4);
 38     append_arr(&arr, 5);
 39 
 40     insert_arr(&arr, 6, 99);//插入，pos值从1开始
 41 
 42     show_arr(&arr);//打印
 43 
 44     if (delete_arr(&arr, 1, &val))//删除元素
 45     {
 46         printf("删除成功\n");
 47         printf("你所删除的元素是%d\n", val);
 48     }
 49     else
 50     {
 51         printf("删除失败\n");
 52     }
 53     
 54     show_arr(&arr);//打印
 55 
 56     inversion_arr(&arr);//逆序
 57     show_arr(&arr);//打印
 58 
 59     sort_arr(&arr);//排序
 60     show_arr(&arr);//打印
 61 
 62     system("pause");
 63 }
 64 
 65 void init_arr(ARR *pArr, int length)//初始化
 66 {
 67     pArr->pBase = (int *)malloc(sizeof(int) * length);
 68     if (pArr->pBase == NULL)
 69     {
 70         printf("内存分配失败\n");
 71     }
 72     else
 73     {
 74         pArr->len = length;
 75         pArr->cnt = 0;
 76     }
 77 }
 78 
 79 bool append_arr(ARR * pArr, int val)//追加
 80 {
 81     if (is_full(pArr))//满了
 82     {
 83         return false;
 84     }
 85     else
 86     {
 87         pArr->pBase[pArr->cnt] = val;
 88         (pArr->cnt)++;
 89         return true;
 90     }
 91 }
 92 
 93 bool insert_arr(ARR * pArr, int pos, int val)//插入，pos值从1开始
 94 {
 95     int i;
 96     if (is_full(pArr))//满了
 97     {
 98         return false;
 99     }
100     if (pos<1 || pos>pArr->cnt + 1)
101     {
102         return false;
103     }
104     for (i = pArr->cnt - 1; i >= pos - 1; i--)
105     {
106         pArr->pBase[i + 1] = pArr->pBase[i];
107     }
108     pArr->pBase[pos - 1] = val;
109     pArr->cnt++;
110     return true;
111 }
112 
113 bool delete_arr(ARR * pArr, int pos, int * pVal)//删除元素
114 {
115     int i = 0;
116     if (is_empty(pArr))//空了
117     {
118         return false;
119     }
120     if (pos<1 || pos>pArr->cnt)
121     {
122         return false;
123     }
124 
125     *pVal = pArr->pBase[pos - 1];//保存将要删除的元素
126 
127     for (i = pos; i < pArr->cnt; i++)
128     {
129         pArr->pBase[i - 1] = pArr->pBase[i];
130     }
131     pArr->cnt--;
132     return true;
133 }
134 
135 bool is_empty(ARR * pArr)//判断是否为空
136 {
137     if (pArr->cnt == 0)
138     {
139         return true;
140     }
141     else
142     {
143         return false;
144     }
145 }
146 
147 bool is_full(ARR * pArr)//判断是否已满
148 {
149     if (pArr->len == pArr->cnt)
150     {
151         return true;
152     }
153     else
154     {
155         return false;
156     }
157 }
158 
159 void sort_arr(ARR * pArr)//排序
160 {
161     int i = 0, j = 0;
162     int t = 0;
163 
164     for (i = 0; i < pArr->cnt - 1; i++)//冒泡
165     {
166         for (j = 0; j < pArr->cnt - 1 - i; j++)
167         {
168             if (pArr->pBase[j]>pArr->pBase[j + 1])
169             {
170                 t = pArr->pBase[j];
171                 pArr->pBase[j] = pArr->pBase[j + 1];
172                 pArr->pBase[j + 1] = t;
173             }
174         }
175     }
176 }
177 
178 void show_arr(ARR *pArr)//打印
179 {
180     if (is_empty(pArr))
181     {
182         printf("数组为空\n");
183     }
184     else
185     {
186         int i = 0;
187         for (i = 0; i < pArr->cnt; i++)
188         {
189             printf("%d ", pArr->pBase[i]);
190         }
191         printf("\n");
192     }
193 }
194 
195 void inversion_arr(ARR *pArr)//逆序
196 {
197     int i = 0;
198     int j = pArr->cnt - 1;
199     int t = 0;
200     while (i < j)
201     {
202         t = pArr->pBase[i];
203         pArr->pBase[i] = pArr->pBase[j];
204         pArr->pBase[j] = t;
205         i++;
206         j--;
207     }
208 }