各种排序算法的比较

最新推荐文章于 2024-02-19 15:18:17 发布
最新推荐文章于 2024-02-19 15:18:17 发布
阅读量2.4k 收藏
点赞数
分类专栏： 排序 文章标签： 算法 merge system jdk ini 作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aihahaheihei/article/details/6784509
版权

这是我很久以前的一个课程设计作业，放这里以后可以参考。

在vc下可以运行，但在dev-c++下有点小问题，算了，我不改了，反正以后也只看那些算法而不需要做这种无聊的课程设计了的。

#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;
#define  N  10000  //产生的数的个数
static __int64 compare_num;  //数据比较次数（不包括比较下标） ,有些排序算法需要不断的调用其他函数，所以要用静态量
static __int64  transmit_num;  //数据传递次数 ,这里一次交换等于3次赋值传递,这里主要是因为有些排序算法是通过插入数据来进行排序的
//直接选择排序
void Select_Sort(int R[],int n){
 compare_num=0;
 transmit_num=0;
 char flag='0';
 cout<<"是否输出所有的数字(1/0):"<<endl;
 cin>>flag;
 while(flag>'1'||flag<'0'){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>flag;
 }
 int i;
 if(flag=='1'){
 cout<<"排序前:"<<endl;
 for( i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
 int k;
 clock_t begin,end;
 begin=clock();  //排序前的时间点
 for(i=1;i<n;i++){  //做n-1 趟选取
  k=i;
  for(int j=i+1;j<=n;j++){     //在i 开始的n-i+1个记录中选取关键码最小的记录
      compare_num++;
   if(R[j]<R[k] )
    k=j;
   if(k!=i){
    R[0]=R[k];
    R[k]=R[i];
    R[i]=R[0];
    transmit_num+=3;
   }
  }
 }
 end=clock();   //排序后的时间点
 if(flag=='1'){
 cout<<"直接选择排序后:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
  cout<<endl;
 }
  double time; 
  time=(double)(end-begin)/CLOCKS_PER_SEC;   //排序所用的时间，下同
        printf("排序过程所用时间为: %.6lf s\n",time);  
  printf("排序过程比较次数为: %I64d\n",compare_num);
  printf("排序过程传递次数为: %I64d\n",transmit_num);
}
  
 
//冒泡排序

void Bubble_Sort(int R[],int n ){ 
 compare_num=0;
 transmit_num=0;
 char flag='0';
 cout<<"是否输出所有的数字(1/0):"<<endl;
 cin>>flag;
 while(flag>'1'||flag<'0'){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>flag;
 }
 int i;
 if(flag=='1'){
 cout<<"排序前:"<<endl;
 for( i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
 clock_t  begin,end;
 begin=clock();
    for(i=1;i<n;i++){  //执行n-1趟
  int swap=0; 
  for(int j=1;j<=n-i;j++){
    compare_num++;
    if(R[j] > R[j+1] ){
     R[0]=R[j];
     R[j]=R[j+1];
     R[j+1]=R[0];
     transmit_num+=3;
     swap=1;
    }
  }
   if(swap==0) // 没有发生一次交换，说明序列有序，则跳出循环，排序结束
     break;
  }
 end=clock();
 if(flag=='1'){
 cout<<"冒泡排序后:"<<endl;
  for(i=1;i<=n;i++)
   cout<<R[i]<<',';
  cout<<endl;
 }
   double time;
  time=(double)(end-begin)/CLOCKS_PER_SEC;
        printf("排序过程所用时间为: %.6lf s\n",time); 
  printf("排序过程比较次数为: %I64d\n",compare_num);
  printf("排序过程传递次数为: %I64d\n",transmit_num);
}
//直接插入排序
void D_InsertSort(int R[],int n){
 compare_num=0;
 transmit_num=0;
 char flag='0';
 cout<<"是否输出所有的数字(1/0):"<<endl;
 cin>>flag;
 while(flag>'1'||flag<'0'){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>flag;
 }
 int i;
 if(flag=='1'){
 cout<<"排序前:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
 clock_t begin,end;
 begin=clock();
 for(i=2;i<=n;i++){
  compare_num++;
  if(R[i]<R[i-1]){  //小于时，需将R[i]插入到有序表适当位置
   R[0]=R[i]; 
   transmit_num++;
   for(int j=i-1;R[j]>R[0];j--){
    R[j+1]=R[j];   // 记录后移
    compare_num++;
    transmit_num++;
   }
   R[j+1]=R[0];   //插入到正确位置
   transmit_num++;
  }
 }
 end=clock();
 if(flag=='1'){
 cout<<"直接插入排序后:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
  double time;
  time=(double)(end-begin)/CLOCKS_PER_SEC;
        printf("排序过程所用时间为: %.6lf s\n",time); 
  printf("排序过程比较次数为: %I64d\n",compare_num);
  printf("排序过程传递次数为: %I64d\n",transmit_num);
}
//希尔排序
void ShellInsert(int R[],int n,int dk){
 int i;
 for(i=dk+1;i<=n;i++){
  compare_num++;
  if(R[i]<R[i-dk]){   //小于时，需R[i]将插入有序表
   R[0]=R[i];   //存储待插入的记录
   transmit_num++;
   for(int j=i-dk;j>0&&R[j]>R[0];j=j-dk){
    R[j+dk]=R[j];  //记录后移
    transmit_num++;
    compare_num++;
   }
   R[j+dk]=R[0];  //插入到正确位置
   transmit_num++;
  }
 }
}
void ShellSort(int R[],int n){
 compare_num=0; 
    transmit_num=0;
 int t[10]={21,19,17,13,11,7,5,3,2,1};  //步长因子中除1外没有公因子，且最后一个步长因子必须为1
 char flag='0';
 cout<<"是否输出所有的数字(1/0):"<<endl;
 cin>>flag;
 while(flag>'1'||flag<'0'){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>flag;
 }
 int i;
 if(flag=='1'){
 cout<<"排序前:"<<endl;
 for( i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
 clock_t begin,end;
 begin=clock();
 for(i=0;i<10;i++)
  ShellInsert(R,n,t[i]);  //调用每个步长因子
 end=clock();
 if(flag=='1'){
 cout<<"希尔排序后:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
  double time;
  time=(double)(end-begin)/CLOCKS_PER_SEC;
        printf("排序过程所用时间为: %.6lf s\n",time); 
  printf("排序过程比较次数为: %I64d\n",compare_num);
  printf("排序过程传递次数为: %I64d\n",transmit_num);
}
//快速排序
int Partition(int R[],int i,int j){ //已R[i]为支点进行划分，算法返回支点记录最终的位置
    R[0]=R[i];  //缓存支点记录
 while(i<j){          //从表的两端交替地向中间扫描
  while(i<j&&R[j]>=R[0])  {
   j--;
   compare_num++;
  }
  if(i<j){   //将比支点记录小的交换到前面
   R[i]=R[j];
   i++;
   transmit_num++;
  }
  while(i<j&&R[i]<R[0]){
   i++;
   compare_num++;
  }
  if(i<j){  //将比支点记录大的交换到后面
   R[j]=R[i];
   j--;
   transmit_num++;
  }
 }
 R[i]=R[0];
 transmit_num++;
 return i;
}
void Quick_Sort(int R[],int s,int t){
 int i;
 if(s<t){
  i=Partition(R,s,t); //将表一分为二
  Quick_Sort(R,s,i-1);  //对支点前端子表递归排序
  Quick_Sort(R,i+1,t);  //对支点后端子表递归排序
 }
}
void Quick(int R[],int n){
 compare_num=0; 
    transmit_num=0;
 char flag='0';
 cout<<"是否输出所有的数字(1/0):"<<endl;
 cin>>flag;
 while(flag>'1'||flag<'0'){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>flag;
 }
 int i;
 if(flag=='1'){
 cout<<"排序前:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
 clock_t begin,end;
 begin=clock();
 Quick_Sort(R,1,n);
 end=clock();
 if(flag=='1'){
     cout<<"快速排序后:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
  double time;
  time=(double)(end-begin)/CLOCKS_PER_SEC;
        printf("排序过程所用时间为: %.6lf s\n",time); 
  printf("排序过程比较次数为: %I64d\n",compare_num);
  printf("排序过程传递次数为: %I64d\n",transmit_num);
}
//堆排序
void HeapAjust(int R[],int s,int t){
 int j;
 R[0]=R[s];
 for(j=2*s;j<=t;j=2*j){  //沿关键码较大的孩子结点向下筛选
  if(j<t && R[j]<R[j+1]){
   compare_num++;
   j++;               //j指向R[i]的关键码较大的孩子
  }
  if(R[0]>R[j]){  //不用调到叶子就到位了
   compare_num++;
   break;
  }
  R[s]=R[j];
  transmit_num++;
  s=j;  //准备向下调整
 }
 R[s]=R[0];  //插入
}
void HeapSort(int R[],int n){
 compare_num=0; 
    transmit_num=0;
 char flag='0';
 cout<<"是否输出所有的数字(1/0):"<<endl;
 cin>>flag;
 while(flag>'1'||flag<'0'){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>flag;
 }
 int i;
 if(flag=='1'){
 cout<<"排序前:"<<endl;
 for( i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
 clock_t begin,end;
 begin=clock();
 for(i=n/2;i>0;i--)
  HeapAjust(R,i,n); //将R[1]……R[n]建成堆
 for(i=n;i>1;i--){
  R[0]=R[1];  //堆顶R[1]与堆底R[i]交换
  R[1]=R[i];
  R[i]=R[0];
  transmit_num+=3;
  HeapAjust(R,1,i-1);  //将R[1]……R[i-1]重新调整为堆
 }
 end=clock();
 if(flag=='1'){
  cout<<"堆排序后:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
  double time;
  time=(double)(end-begin)/CLOCKS_PER_SEC;
        printf("排序过程所用时间为: %.6lf s\n",time); 
  printf("排序过程比较次数为: %I64d\n",compare_num);
  printf("排序过程传递次数为: %I64d\n",transmit_num);
}
//归并排序
void Merge(int R[],int s,int m,int t){  //把两个有序子表归并
 int i,j;
 i=s;
 j=m+1;
 int p=0;
 int R1[N];
 while(i<=m&&j<=t){
  compare_num++;
  if(R[i]<R[j]){ 
   R1[p]=R[i];
   p++;
   i++; 
   transmit_num++;
  }
  else{
   R1[p]=R[j];
   p++;
   j++;
   transmit_num++;
  }
 }
  while(i<=m){
   R1[p]=R[i];
   p++;
   i++;
   transmit_num++;
  }
  while(j<=t){
   R1[p]=R[j];
   p++;
   j++;
   transmit_num++;
  }
 
  for(p=0,i=s;i<=t;i++,p++){
   R[i]=R1[p];
   transmit_num++;
  }
}
void Msort(int R[],int s,int t){
 int m;
 if(s<t){
  m=(s+t)/2;
  Msort(R,s,m); //递归地将R[s]~R[m]归并为有序的R1[s]~R1[m]
  Msort(R,m+1,t);  //递归地将R[m+1]~R[t]归并为有序的R1[m+1]~R1[t]
  Merge(R,s,m,t);  //将R1[s]~R1[m]和R1[m+1]~R1[t]归并到R[s]~R[t]
 }
}
void MergeSort(int R[],int n){
 compare_num=0; 
    transmit_num=0;
 char flag='0';
 cout<<"是否输出所有的数字(1/0):"<<endl;
 cin>>flag;
 while(flag>'1'||flag<'0'){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>flag;
 }
 int i;
 cout<<"排序前:"<<endl;
    if(flag=='1'){
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
 clock_t begin,end;
 begin=clock();
 Msort(R,1,n);
 end=clock();
 if(flag=='1'){
  cout<<"归并排序后:"<<endl;
 for(i=1;i<=n;i++)
  cout<<R[i]<<',';
 cout<<endl;
 }
  double time;
  time=(double)(end-begin)/CLOCKS_PER_SEC;
        printf("排序过程所用时间为: %.6lf s\n",time); 
  printf("排序过程比较次数为: %I64d\n",compare_num);
  printf("排序过程传递次数为: %I64d\n",transmit_num);

}

 int  main(){
  while(1){
    int R[N+1],i;
 cout<<"1   在完全随机的情况下对关键码进行排序"<<endl;
 cout<<"2   在完全正序的情况下对关键码进行排序"<<endl;
 cout<<"3   在完全逆序的情况下对关键码进行排序"<<endl;
 cout<<"0   退出"<<endl;
 cout<<"请选择:"<<endl;
 char p;
 cin>>p;
 while(p-48<0||p-48>3){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>p;
 }
 if(p-48==0)
  break;
 if(p-48==1){
     srand((unsigned)time(NULL));
 for(i=1;i<=N;i++)
  R[i]=rand()%10000+1;
 }
 else if(p-48==2){
  for(i=1;i<=N;i++)
   R[i]=i;
 }
 else
  for(i=N;i>=1;i--)
   R[N-i+1]=i;

 char k;
 cout<<endl;
 cout<<"1   直接插入排序"<<endl;
 cout<<"2   希尔排序"<<endl;
 cout<<"3   冒泡排序"<<endl;
 cout<<"4   快速排序"<<endl;
 cout<<"5   直接选择排序"<<endl;
 cout<<"6   堆排序"<<endl;
 cout<<"7   归并排序"<<endl;
 cout<<"0   退出程序"<<endl;
 cout<<"请选择排序方法:"<<endl;
 cin>>k;
 while(k-48<0||k-48>7){
  cout<<"输入有误，请重新输入:"<<endl;
  cin>>k;
 }
 switch(k-48){
 case 0:cout<<"谢谢使用!"<<endl;exit(0);
 case 1:D_InsertSort(R,N);break;
 case 2:ShellSort(R,N);break;
 case 3:Bubble_Sort(R,N);break;
 case 4:Quick(R,N);break;
 case 5:Select_Sort(R,N);break;
 case 6:HeapSort(R,N);break;
 case 7:MergeSort(R,N);break;
 }
 system("pause");system("cls");
 }
 return 0;
}

 

 

DeDeWo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
各种排序算法比较1
08-03
示例 1：输出：[1,2,3,5]示例 2：输出：[0,0,1,1,2,5]解题思路：比较多种排序算法，最终只有堆排序，快排，归并排序符合时间复杂度要求* No
数据结构课程设计各种排序算法比较.doc
11-29
数据结构课程设计各种排序算法比较.doc
java各种排序算法比较.docx
06-20
排序算法是数据结构中十分基础的内容，本文总结了常用的排序算法的原理和性能，还给出了相关的图解，并且采用java语言实现了算法，最后给了一个面试中实际的例子，以及算法复杂度的比较
各种排序算法比较
12-01
各种排序算法的总结和比较 非常实用 希望大家喜欢
各种排序算法比较.doc
09-20
各种排序算法比较
排序算法的详解和分析对比（详细讲解）
gongjunbox的博客
10-31 6098
排序算法各式各样，每种排序算法的思想也大同小异。读者应该深度了解每种算法的基本思想、排序每一步过程细节和每种排序的特性，看到特定的序列，应该立马想到最适合的排序方法。一些简单的排序算法中，虽然效率不高，但是在低数量规模情况下，就比如一万数量级以下，一般运行时间还能可以被人们所接受，零点几秒左右很难被察觉出来。但是如果到了十万数量级，排序就需要非常久的时间，可能会导致我们一些系统会出现误差，从而引起巨大的麻烦和问题。
常见七种排序算法对比（超全！！！）
qq_54850622的博客
04-15 9890
一，冒泡排序 最常见的排序实现起来很简单，不过实际应用很少，复杂度O(n²)。 原理：一趟一趟的比，每一趟中，循环剩余的数，和后一个进行比较，若比它小则交换。这样一趟下来最小的在第一个，最大的在最后一个。总共需要比n-1趟。 public static void BubbleSort(int []array){ for(int i=1;i<array.length;i++) { for(int j=0;j<array.length-1;j++) .
分治算法的经典案例——合并排序
实践求真知
02-26 5427
一算法设计 合并排序是采用分治策略进行排序的算法，是分治算法的一个典型应用和完美体现。它是一种平衡、简单的二分分治策略。 算法步骤如下。 1分解 将待排序元素分成大小大致相同的两个子序列。 2治理 对两个子序列进行合并排序。 3合并 将排好序的有序子序列进行合并，得到最终的有序序列。 二算法图解 首先将待排序的元素分成大小大致相同的两个子序列，然后把子序列分成大小大致相同的两个子序列，如此下去，直到分解成一个元素为止，这时含有一个元素的子序列就是有序的；然后执行合并操作，将...
【数据结构从青铜到王者】第九篇:数据结构之排序
森明帮大于黑虎帮的博客
05-20 1926
系列文章目录 文章目录系列文章目录前言一、排序的概念1.排序的概念二、常见排序算法的实现1.插入排序1.基本思想2.代码实现2.希尔排序1.基本思想2.代码实现3.选择排序1.基本思想2.代码实现4.堆排序1.基本思想2.代码实现5.冒泡排序1.基本思想2.代码实现6.快速排序递归思想1.左右指针法1.基本思想2.代码实现2.挖坑法1.基本思想2.代码实现3.前后指针法1.基本思想2.代码实现4.快速排序优化方法1.三数取中法2.小区间排序优化7.快速排序非递归思想1.基本思想2.代码实现8.归并排序递.
各种排序算法比较文档.pdf
07-14
各种排序算法比较文档.pdf
几种排序方法的C语言实现
blh的专栏
06-06 1097
 #include #include #define SORT_ASCENDING (1)#if SORT_ASCENDING#define compare_num(a,b)    ((a) > (b))#else#define compare_num(a,b)    ((a) #endif#define NUM    (10)//=======
指针简介（3）—— 指针函数与函数指针
静祥阁
03-18 797
声明： 本文是阅读周立功老师的程序设计与数据结构后所写，很多内容其实是书中的内容，所以如果您想了解更多这方面的知识，您可以阅读这本书。 在前面一节我们简单介绍了指针、数组、指针数组以及数组指针。而在这一节中我们主要介绍两个概念：函数指针函数以及函数指针。 指针函数： 说到指针函数，他的主体还是一个函数，但是他的返回值为指针类型，因此我们...
C++中的compare函数怎么用？
最新发布
Kp0fS的草稿纸
02-19 839
C++中的compare函数怎么用？ 在C++中，compare函数不是内建（built-in）的函数，但
【常见的十种排序算法及稳定性比较】
阿年的博客
03-29 1349
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、基数排序、基数排序、桶排序，以及稳定性比较，总结
常用排序算法比较与分析
WonderZYP的博客
10-24 2630
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、各种排序算法比较 二、具体排序算法介绍 2.1 冒泡排序 2.2 选择排序 总结 前言 我们在平时学习和工作中经常用到各种排序算法，不仅要考虑算法的时间空间复杂度也要注意稳定性问题。为更好的理解排序算法，在此整理出常见的排序算法，包括：选择排序、冒泡排序、插入排序、快速排序、归并排序、堆排序、希尔排序、桶排序、计数排序、基数排序。 一、各种排序算法比较 复...
分治法实现合并排序
dsy020210的博客
05-22 246
对合并排序而言,我们将待排序的元素序列一分为二,得到两个长度基本相等的子序列,类似二分查找的做法,然后对两个子序列分别排序,如果序列较长,还可继续细分，直到子序列的长度不超过1为止;当分解所得的子序列已排列有序时.可以采用上面介绍的方法,将两个有序序列合并成一个有序子序列,实现将子问题解合成原问题解.分治法的基本思想是分而治之,分治法的三要素为。
【超详细】八大排序算法的各项比较以及各自特点
热门推荐
qq_45615577的博客
03-27 2万+
千万不要错过这篇，不然你就亏大发了。 八大排序,各显神通。 前言 一、排序的概念 二、各算法特点 1.直接选择排序 2.堆排序 3.直接插入排序 4.希尔排序 5.冒泡排序 6.快速排序 7.归并排序 8.基数排序 总结 前言 排序是计算机程序设计中一个非常重要的操作，它将一个数据元素（或记录）的任意序列重新排列成一个按关键字有序的序列。在有序的序列中查找元素的效率很高，（例如，折半查找法的平均查找长度为log2(n+1)−1log2(n+1...
十大排序算法比较
WANGHAOXIN364的博客
07-28 1581
排序算法
各种排序算法的复杂度
09-14
各种排序算法的复杂度取决于输入数据的规模（n）和算法的执行步骤数（T）。以下是一些常见排序算法及其平均和最差情况下的时间复杂度： 1. 冒泡排序（Bubble Sort）： - 平均复杂度：O(n^2) - 最差情况：O(n^2) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值