数据结构实验报告（六）

  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 }