1 #include <iostream>
2 #include <stdio.h>
3 #include <stdlib.h>
4 #define INFINITY INT_MAX
5 #define MAXSIZE 100
6
7 using namespace std;
8 typedef struct list
9 {int key;
10 }ElemType;
11 typedef struct {
12 ElemType data[MAXSIZE+1];
13 int length; /*参加排序元素的实际个数*/
14 }SeqList;
15 //创建顺序表
16 void creatList(SeqList &l)
17 {
18 cout<<"请输入数据个数"<<endl;
19 cin>>l.length;
20 cout<<"请顺次输入一组无序数据"<<endl;
21 for (int i=1;i<=l.length;i++)
22 {
23 cin>>l.data[i].key;
24 }
25 }
26 // 直接插入排序
27 void InsertSort(SeqList &l)
28 {
29 int i,j;
30 for (i=2;i<=l.length;i++)
31 {
32 if (l.data[i].key < l.data[i-1].key )
33 {
34 l.data[0].key=l.data[i].key;
35 l.data[i].key=l.data[i-1].key;
36 for (j=i-2;l.data[0].key < l.data[j].key ;j--)
37 l.data[j+1].key=l.data[j].key;
38 l.data[j+1].key=l.data[0].key;
39 }
40 }
41 }
42 //输出顺序表元素
43 void print(SeqList l)
44 {
45 int i;
46 for (i=1;i<=l.length;i++)
47 cout<<l.data[i].key<<" ";
48 cout<<endl;
49 }
50 //冒泡排序
51 void BubbleSort(SeqList &l)
52 {
53 int i,j;
54 for (i=1;i<=l.length-1;i++)
55 for (j=1;j<=l.length-i;j++)
56 {
57 if (l.data[j].key > l.data[j+1].key)
58 {
59 l.data[0]=l.data[j];
60 l.data[j]=l.data[j+1];
61 l.data[j+1]=l.data[0];
62 }
63 }
64 }
65 // 直接选择排序
66 void SelectSort(SeqList &l)
67 {
68 int i,j,k;
69 for (i=1;i<=l.length-1;i++)
70 {
71 k=i;
72 for (j=i;j<=l.length;j++)
73 {
74 if (l.data[j].key<l.data[k].key)
75 {
76 k=j;
77 }
78 }
79 if (k!=i)
80 {
81 l.data[0]=l.data[k];
82 l.data[k]=l.data[i];
83 l.data[i]=l.data[0];
84 }
85 }
86 }
87 //希尔插入
88 void ShellInsert(SeqList &l,int dk)
89 {
90 //dk是位置增量
91 int i,j;
92 for (i=dk+1;i<=l.length;i++)
93 {
94 if (l.data[i].key < l.data[i-dk].key)
95 {
96 l.data[0]=l.data[i];
97 for (j=i-dk;j>0&&l.data[0].key<l.data[j].key;j=j-dk)
98 {
99 l.data[j+dk]=l.data[j];
100 }
101 l.data[j+dk]=l.data[0];
102 }
103 }
104 }
105 //希尔排序
106 void ShellSort(SeqList &l,int dlta[],int t)
107 {
108 //dlta[]是增量数组，每一次循环以dlta[k]为增量，dlta[0---t-1]
109 int k;
110 for (k=0;k<t;k++)
111 ShellInsert(l,dlta[k]);
112 }
113 //快排
114 int Partition(SeqList &l,int low,int high)
115 {
116 l.data[0]=l.data[low];
117 int p;
118 p=l.data[low].key;
119 while (low<high)
120 {
121 while (low<high&&l.data[high].key>=p) high--;
122 l.data[low]=l.data[high];
123 while (low<high&&l.data[low].key<=p) low++;
124 l.data[high]=l.data[low];
125 }
126 l.data[low]=l.data[0];
127 return low;
128 }
129 void QSort(SeqList &l,int low,int high)
130 {
131 int p;
132 if (low<high)
133 {
134 p=Partition(l,low,high);
135 QSort(l,low,p-1);
136 QSort(l,p+1,high);
137 }
138 }
139
140 //堆调整
141 void HeapAdjust(SeqList &l,int s,int m)
142 {
143 ElemType rc=l.data[s];
144 int j;
145 for (j=2*s;j<=m;j*=2)
146 {
147 if (j<m && l.data[j].key < l.data[j+1].key)
148 j++;
149 if (!(rc.key < l.data[j].key))
150 break;
151 l.data[s]=l.data[j];s=j;
152 }
153 l.data[s]=rc;
154 }
155 //堆排序
156 void HeapSort(SeqList &l)
157 {
158 int i;
159 for (i=l.length/2;i>0;i--)
160 HeapAdjust(l,i,l.length);
161 for (i=l.length;i>1;i--)
162 {
163 l.data[0]=l.data[1];
164 l.data[1]=l.data[i];//data[1]即为最大的数
165 l.data[i]=l.data[0];
166 HeapAdjust(l,1,i-1);
167 }
168
169
170 }
171
172 //折半插入排序
173 void BinInsertSort(SeqList &l)
174 {
175 int i,j,low,high,mid;
176 for (i=2;i<=l.length;i++)
177 {
178 l.data[0]=l.data[i];
179 low=1;high=i-1;
180 while (low<=high)
181 {
182 mid=(low+high)/2;
183 if (l.data[0].key < l.data[mid].key ) high=mid-1;
184 else low=mid+1;
185 }
186 for (j=i-1;j>=high+1;j--)
187 l.data[j+1]=l.data[j];
188 l.data[high+1]=l.data[0];
189 }
190 }
191 // 链式存储实现简单选择排序
192 typedef struct LNode
193 {
194 ElemType data;
195 struct LNode *next;
196 }LNode,*linklist;
197 //创建单链表l
198 void createLinkList(linklist &l)
199 {
200 linklist p,q;
201 l=(linklist)malloc(sizeof(LNode));
202 p=l;
203 cout<<"请输入数据个数"<<endl;
204 int n;cin>>n;
205 cout<<"请输入一组数据"<<endl;
206 ElemType e;
207
208 for (int i=0;i<n;i++)
209 {
210 cin>>e.key;
211 q=(linklist)malloc(sizeof(LNode));
212 q->data.key=e.key;
213 q->next=NULL;
214 p->next=q;
215 p=q;
216 }
217
218 }
219 // 简单选择排序
220 void SelectSort_linklist(linklist &l)
221 {
222 ElemType tmp;
223 linklist p,q,k;//P为工作指针，Q为指向最小元素的指针,k为前面指向第一个为排序元素的指针
224 p=l->next;q=p;k=p;
225 while (k)
226 {
227
228 while (p)
229 {
230 if (p->data.key < q->data.key )
231 {
232 q=p;
233 }
234 p=p->next;
235 }
236 if (k!=q)
237 {
238 tmp=k->data;
239 k->data=q->data;
240 q->data=tmp;
241 }
242 k=k->next;
243 p=k;
244 q=k;
245 }
246 }
247 //打印链表
248 void print_linklist(linklist l)
249 {
250 linklist p=l->next;
251 while (p)
252 {
253 cout<<p->data.key<<" ";
254 p=p->next;
255 }
256 cout<<endl;
257 }
258 // 链式直接插入排序
259 void InsertSort_linklist(linklist &l)
260 {
261 linklist p,q,t;
262 p=l->next->next;//把P插入到链表L中
263 l->next->next=NULL;
264 q=l;
265 while (p)
266 {
267 while (q->next && p->data.key >q->next->data.key)
268 q=q->next;
269 if (!q)
270 {
271 q->next = p;
272 p=p->next;
273 p->next=NULL;
274 }
275 else
276 {
277 t=p;p=p->next;
278 t->next=q->next;
279 q->next=t;
280 }
281 q=l;
282 }
283 }
284 // 链式冒泡排序
285 void BubbleSort_linklist(linklist &l)
286 {
287 linklist p=l->next,q,c;
288 q=p->next;
289 ElemType e;
290 c=p;
291 while (c)
292 {
293 while (q)
294 {
295
296 if (p->data.key > q->data.key )
297 {
298 e=p->data;
299 p->data=q->data;
300 q->data=e;
301 }
302 p=p->next;q=q->next;
303 }
304 p=l->next,q=p->next;
305 c=c->next;
306 }
307
308
309 }
310 int main()
311 { cout<<"--------------------------------------------------------"<<endl;
312 cout<<"1.InsertSort():直接插入排序"<<endl;
313 cout<<"2.Bl.data[1]ubbleSort():冒泡排序"<<endl;
314 cout<<"3.SelectSort():直接选择排序"<<endl;
315 cout<<"4.ShellSort():希尔排序"<<endl;
316 cout<<"5.QSort():快速排序"<<endl;
317 cout<<"6.HeapSort():堆排序"<<endl;
318 cout<<"7.BinInsertSort():折半插入排序"<<endl;
319 cout<<"9.SelectSort_linklist():链式简单选择排序"<<endl;
320 cout<<"10.InsertSort_linklist():链式直接插入排序"<<endl;
321 cout<<"11.BubbleSort_linklist():链式冒泡排序"<<endl;
322 cout<<"--------------------------------------------------------"<<endl;
323 ll1:cout<<"请输入您选择的函数序号"<<endl;
324 int x;cin>>x;
325 SeqList l;
326 linklist l1;
327 switch(x)
328 {
329 case 1:
330 {
331 creatList(l);
332 cout<<"直接插入排序前的结果"<<endl;
333 print(l);
334 InsertSort(l);
335 cout<<"直接插入排序后的结果"<<endl;
336 print(l);
337 break;
338 }
339
340 case 2:
341 {
342 creatList(l);
343 cout<<"冒泡排序前的结果"<<endl;
344 print(l);
345 BubbleSort(l);
346 cout<<"冒泡排序后的结果"<<endl;
347 print(l);
348 break;
349 }
350
351 case 3:
352 {
353 creatList(l);
354 cout<<"直接选择排序前的结果"<<endl;
355 print(l);
356 SelectSort(l);
357 cout<<"直接选择排序后的结果"<<endl;
358 print(l);
359 break;
360 }
361 case 4:
362 creatList(l);
363 cout<<"希尔排序前的结果"<<endl;
364 print(l);
365 int dlta[3];dlta[0]=5;dlta[1]=3;dlta[2]=1;
366 ShellSort(l,dlta,3);
367 cout<<"希尔排序后的结果"<<endl;
368 print(l);
369 break;
370
371 case 5:
372 creatList(l);
373 cout<<"快速排序前的结果"<<endl;
374 print(l);
375 QSort(l,1,8);
376 cout<<"快速排序后的结果"<<endl;
377 print(l);
378 break;
379
380 case 6:
381 {
382 creatList(l);
383 cout<<"堆排序前的结果"<<endl;
384 print(l);
385 HeapSort(l);
386 cout<<"堆排序后的结果"<<endl;
387 print(l);
388 break;
389 }
390
391 case 7:
392 {
393 creatList(l);
394 cout<<"折半插入排序前的结果"<<endl;
395 print(l);
396 BinInsertSort(l);
397 cout<<"折半插入排序后的结果"<<endl;
398 print(l);
399 break;
400 }
401 case 9:
402 {
403 createLinkList(l1);
404 cout<<"链式简单选择排序之前："<<endl;
405 print_linklist(l1);
406 SelectSort_linklist(l1);
407 cout<<"链式简单选择排序之后："<<endl;
408 print_linklist(l1);
409 break;
410 }
411 case 10:
412 {
413 createLinkList(l1);
414 cout<<"链式直接插入排序之前："<<endl;
415 print_linklist(l1);
416 InsertSort_linklist(l1);
417 cout<<"链式直接插入排序之后："<<endl;
418 InsertSort_linklist(l1);
419 break;
420 }
421
422 case 11:
423 {
424 createLinkList(l1);
425 cout<<"链式冒泡排序之前："<<endl;
426 print_linklist(l1);
427 BubbleSort_linklist(l1);
428 cout<<"链式冒泡排序之后："<<endl;
429 print_linklist(l1);
430 break;
431 }
432
433
434
435
436 }
437 cout<<"您是否还要继续测试其他函数？y/n"<<endl;
438 fflush(stdin);
439 char z;
440 cin>>z;
441 if (z=='y')
442 goto ll1;
443 else
444 return 0;
445 }