当前位置:   article > 正文

数据结构:实验八:数据排序

数据结构:实验八:数据排序

一、    实验目的

(1)掌握各种排序算法的过程和算法设计

(2)体会各种排序算法的性能。

二、  实验要求

编写程序分别采用直接插入排序算法 、折半插入排序算法、冒泡排序算法、快速排序算法,实现对任意一组整型数据(无序),分别输出各一趟的排序结果。

 三、实验环境

Windows+DEV C++( 或者其他编译工具)

四、实验步骤及结果 

1.类型声明

  1. typedef int ElemType;
  2. typedef struct {
  3.    ElemType key;
  4. } RecType;//排序元素的类型

2.各类排序算法的实现

//直接插入排序

  1. void InsertSort(RecType R[],int n) {//对R[0..n-1]按递增有序进行直接插入排序
  2.    RecType tmp;
  3.    int i,j;
  4.    for(i=0; i<n; i++) {
  5.        if(R[i].key<R[i-1].key) {//反序时
  6.           tmp=R[i];
  7.           j=i-1;
  8.           do {//找R[i]的插入位置
  9.               R[j+1]=R[j];//将关键字大于R[i].key的记录后移
  10.               j--;
  11.           } while(j>=0&&R[j].key>tmp.key);
  12.           R[j+1]=tmp;//在j+1处插入R[i]
  13.        }
  14.    }
  15. }

//折半插入排序

  1. void BinInsertSort(RecType R[],int n) {
  2.    int i,j,low,high,mid;
  3.    RecType tmp;
  4.    for(i=1; i<n; i++) {
  5.        if(R[i].key<R[i-1].key) {//反序时
  6.           tmp=R[i];//将R[i]保存到tmp中
  7.           low=0;
  8.           high=i-1;
  9.           while(low<=high) {//在R[low..high]中查找插入的位置
  10.               mid=(low+high)/2;//取中间位置
  11.               if(tmp.key<R[mid].key)
  12.                  high=mid-1;//插入点在左半区
  13.               else
  14.                  low=mid+1;//插入点在右半区
  15.           }//找位置high+1
  16.           for(j=i-1; j>=high+1; j--)//集中进行元素的后移
  17.               R[j+1]=R[j];
  18.           R[high+1]=tmp;//插入tmp
  19.        }
  20.    }
  21. }

//冒泡排序

  1. void BubbleSort(RecType R[],int n) {
  2.    int i,j;
  3.    for(i=0; i<n-1; i++)
  4.        for(j=n-1; j>i; j--)//将R[i]元素归位
  5.           if(R[j].key<R[j-1].key) //相邻的两个元素反序时
  6.               swap(R[j],R[j-1]);//将R[j]和R[j-1]两个元素交换
  7. }

//快速排序

  1. int partition(RecType R[],int s,int t) {//一趟划分
  2.    int i=s,j=t;
  3.    RecType base=R[i];//以R[i]为基准
  4.    while(i<j) {//从两端交替向中间扫描,直到i=j为止
  5.        while(j>i&&R[j].key>=base.key)
  6.           j--;//从右往左遍历,找一个小于base.key的R[j]
  7.        if(i<j) {
  8.           R[i]=R[j];
  9.           i++;
  10.        }
  11.        while(i<j&&R[i].key<=base.key)
  12.           i++;//从左往右遍历,找一个大于base.key的R[i]
  13.        if(i<j) {
  14.           R[i]=R[j];
  15.           j--;
  16.        }
  17.    }
  18.    R[i]=base;
  19.    return i;
  20. }
  21. void QuickSort(RecType R[],int s,int t) {//对R[s..t]中的元素进行快速排序
  22.    int i;
  23.    if(s<t) {//区间内至少存在两个元素的情况
  24.        i=partition(R,s,t);
  25.        QuickSort(R,s,i-1);//对左区间递归排序
  26.        QuickSort(R,i+1,t);//对右区间递归排序
  27.    }
  28. }

3.主程序设计及完成实验要求中的功能

  1. //输出
  2. void Display(RecType R[],int n) {
  3.    for(int i=0; i<n; i++)
  4.        cout<<R[i].key<<" ";
  5.    cout<<endl;
  6. }
  7. //主面板
  8. void Interface() {
  9.    cout<<"0.退出程序"<<endl;
  10.    cout<<"1.直接插入排序算法"<<endl;
  11.    cout<<"2.折半插入排序算法"<<endl;
  12.    cout<<"3.冒泡排序算法"<<endl;
  13.    cout<<"4.快速排序算法"<<endl;
  14.    cout << "请输入选择:";
  15. }
  16. //选择匹配面板
  17. void Select(RecType R[],int n,int x) {
  18.    switch(x) {
  19.        case 0:
  20.           cout << "已退出程序!";
  21.           exit(0);
  22.        case 1:
  23.           InsertSort(R,n);
  24.           Display(R,n);
  25.           break;
  26.        case 2:
  27.           BinInsertSort(R,n);
  28.           Display(R,n);
  29.           break;
  30.        case 3:
  31.           BubbleSort(R,n);
  32.           Display(R,n);
  33.           break;
  34.        case 4:
  35.           QuickSort(R,1,n-1);
  36.           Display(R,n);
  37.           break;
  38.    };
  39. }
  40. int main() {
  41.    int n=0,x;
  42.    RecType R[N]= {5,8,6,10,1,4,9,7,3,2};
  43.    for(int i=0; i<N&&R[i].key!=0; i++)
  44.        n++;
  45.    cout<<"初始序列为:"<<endl;
  46.    Display(R,n);
  47.    cout<<endl;
  48.    while(1) {
  49.        Interface();
  50.        cin>>x;
  51.        while(!(x==0||x==1||x==2||x==3||x==4)) {
  52.           system("cls");
  53.           cout<<"输入错误请重新输入!"<<endl;
  54.           Interface();
  55.           cin>>x;
  56.        }
  57.        Select(R,n,x);
  58.    }
  59. }

完整代码:

  1. #include<iostream>
  2. using namespace std;
  3. #define N 100
  4. typedef int ElemType;
  5. typedef struct {
  6. ElemType key;
  7. } RecType;//排序元素的类型
  8. //直接插入排序
  9. void InsertSort(RecType R[],int n) {//对R[0..n-1]按递增有序进行直接插入排序
  10. RecType tmp;
  11. int i,j;
  12. for(i=0; i<n; i++) {
  13. if(R[i].key<R[i-1].key) {//反序时
  14. tmp=R[i];
  15. j=i-1;
  16. do {//找R[i]的插入位置
  17. R[j+1]=R[j];//将关键字大于R[i].key的记录后移
  18. j--;
  19. } while(j>=0&&R[j].key>tmp.key);
  20. R[j+1]=tmp;//在j+1处插入R[i]
  21. }
  22. }
  23. }
  24. //折半插入排序
  25. void BinInsertSort(RecType R[],int n) {
  26. int i,j,low,high,mid;
  27. RecType tmp;
  28. for(i=1; i<n; i++) {
  29. if(R[i].key<R[i-1].key) {//反序时
  30. tmp=R[i];//将R[i]保存到tmp中
  31. low=0;
  32. high=i-1;
  33. while(low<=high) {//在R[low..high]中查找插入的位置
  34. mid=(low+high)/2;//取中间位置
  35. if(tmp.key<R[mid].key)
  36. high=mid-1;//插入点在左半区
  37. else
  38. low=mid+1;//插入点在右半区
  39. }//找位置high+1
  40. for(j=i-1; j>=high+1; j--)//集中进行元素的后移
  41. R[j+1]=R[j];
  42. R[high+1]=tmp;//插入tmp
  43. }
  44. }
  45. }
  46. //冒泡排序
  47. void BubbleSort(RecType R[],int n) {
  48. int i,j;
  49. for(i=0; i<n-1; i++)
  50. for(j=n-1; j>i; j--)//将R[i]元素归位
  51. if(R[j].key<R[j-1].key) //相邻的两个元素反序时
  52. swap(R[j],R[j-1]);//将R[j]和R[j-1]两个元素交换
  53. }
  54. //快速排序
  55. int partition(RecType R[],int s,int t) {//一趟划分
  56. int i=s,j=t;
  57. RecType base=R[i];//以R[i]为基准
  58. while(i<j) {//从两端交替向中间扫描,直到i=j为止
  59. while(j>i&&R[j].key>=base.key)
  60. j--;//从右往左遍历,找一个小于base.key的R[j]
  61. if(i<j) {
  62. R[i]=R[j];
  63. i++;
  64. }
  65. while(i<j&&R[i].key<=base.key)
  66. i++;//从左往右遍历,找一个大于base.key的R[i]
  67. if(i<j) {
  68. R[i]=R[j];
  69. j--;
  70. }
  71. }
  72. R[i]=base;
  73. return i;
  74. }
  75. void QuickSort(RecType R[],int s,int t) {//对R[s..t]中的元素进行快速排序
  76. int i;
  77. if(s<t) {//区间内至少存在两个元素的情况
  78. i=partition(R,s,t);
  79. QuickSort(R,s,i-1);//对左区间递归排序
  80. QuickSort(R,i+1,t);//对右区间递归排序
  81. }
  82. }
  83. //输出
  84. void Display(RecType R[],int n) {
  85. for(int i=0; i<n; i++)
  86. cout<<R[i].key<<" ";
  87. cout<<endl;
  88. }
  89. //主面板
  90. void Interface() {
  91. cout<<"0.退出程序"<<endl;
  92. cout<<"1.直接插入排序算法"<<endl;
  93. cout<<"2.折半插入排序算法"<<endl;
  94. cout<<"3.冒泡排序算法"<<endl;
  95. cout<<"4.快速排序算法"<<endl;
  96. cout << "请输入选择:";
  97. }
  98. //选择匹配面板
  99. void Select(RecType R[],int n,int x) {
  100. switch(x) {
  101. case 0:
  102. cout << "已退出程序!";
  103. exit(0);
  104. case 1:
  105. InsertSort(R,n);
  106. Display(R,n);
  107. break;
  108. case 2:
  109. BinInsertSort(R,n);
  110. Display(R,n);
  111. break;
  112. case 3:
  113. BubbleSort(R,n);
  114. Display(R,n);
  115. break;
  116. case 4:
  117. QuickSort(R,1,n-1);
  118. Display(R,n);
  119. break;
  120. };
  121. }
  122. int main() {
  123. int n=0,x;
  124. RecType R[N]={28,16,32,12,60,2,5,72};
  125. //RecType R[N]= {5,8,6,10,1,4,9,7,3,2};
  126. for(int i=0; i<N&&R[i].key!=0; i++)
  127. n++;
  128. cout<<"初始序列为:"<<endl;
  129. Display(R,n);
  130. cout<<endl;
  131. while(1) {
  132. Interface();
  133. cin>>x;
  134. while(!(x==0||x==1||x==2||x==3||x==4)) {
  135. system("cls");
  136. cout<<"输入错误请重新输入!"<<endl;
  137. Interface();
  138. cin>>x;
  139. }
  140. Select(R,n,x);
  141. }
  142. }

4.实验结果截图

如需源文件,请私信作者,无偿

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/很楠不爱3/article/detail/521330
推荐阅读
相关标签
  

闽ICP备14008679号