排序算法，你会几个？？？

  做者 |  三玖天下第一   

来源 | cnblogs.com/hzoi-liujiahui/p/13256439.html

一、冒泡排序

• 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，若是它们的顺序错误就把它们交换过来。走访数列的工做是重复地进行直到没有再须要交换，也就是说该数列已经排序完成。这个算法的名字由来是由于越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

• n个元素的序列，通过n-1趟选择排序获得有序结果。具体算法描述以下：

1. 初始状态：无序区为R[1..n]，有序区为空；

2. 每一轮从无序区起点开始，相邻元素两两比较，若是前面的比后面的元素大就交换，直到无序区最后。

3. 针对全部的元素重复以上的步骤，每一轮冒泡操做无序区域元素减一，有序区元素减一；

4. 重复执行n-1轮，序列变为有序。

1.2 动图演示

1.3 代码实现

#include <bits/stdc++.h>
const int maxn=1e4+5,Inf=2147483647;
int a[maxn];
int n;
void Read(){
  scanf("%d",&n);
  srand(time(0));
  for(int i=1;i<=n;++i)
    a[i]=rand()%10000;
}
void Print(){
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
}
void Bubble_sort(int a[]){
  for(int i=1;i<n;++i){//通过n-1轮的冒泡操做
    for(int j=1;j<=n-i;++j)//没操做一轮，待排序的少一个
      if(a[j]>a[j+1])
        std::swap(a[j],a[j+1]);
  }
}
void Solve(){
  Read();
  Bubble_sort(a);
  Print();
}
int main(){
  Solve();
  return 0;
}

2.选择排序

• 选择排序(Selection-sort)是一种简单直观的排序算法。它的工做原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而后，再从剩余未排序元素中继续寻找最小（大）元素，而后放到已排序序列的末尾。以此类推，直到全部元素均排序完毕。

2.1 算法描述

• n个记录的直接选择排序可通过n-1趟直接选择排序获得有序结果。具体算法描述以下：

1. 初始状态：无序区为R[1..n]，有序区为空；

2. 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增长1个的新有序区和记录个数减小1个的新无序区；

3. n-1趟结束，数组有序化了。

2.2 动图演示

2.3 代码实现

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
      
 
     
    
      
    
    
    
     
     
              
     
     


   
     
   
   
   
    
    
             
    
    
#include <bits/stdc++.h>
const int maxn=1e4+5,Inf=2147483647;
int a[maxn];
int n;
void Read(){
  scanf("%d",&n);
  srand(time(0));
  for(int i=1;i<=n;++i)
    a[i]=rand()%10000;
}
void Print(){
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
}
void Select_sort(int a[]){
  int k=0;
  for(int i=1;i<n;++i){//n-1轮，每一轮找到一个最小的
    k=i;//k指向未排序的最小
    for(int j=i+1;j<=n;++j)
      if(a[k]>a[j])
        k=j;
    std::swap(a[i],a[k]);
  }
}
void Solve(){
  Read();
  Select_sort(a);
  Print();
}
int main(){
  Solve();
  return 0;
}

3. 插入排序

• 插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工做原理是经过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

1. 从第一个元素开始，该元素能够认为已经被排序；

2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；

3. 若是该元素（已排序）大于新元素，将该元素移到下一位置；

4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

5. 将新元素插入到该位置后；

6. 重复步骤2~5。

3.2 动图演示

3.3 代码实现

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
      
 
     
   
     
   
   
   
    
    
             
    
    
#include <bits/stdc++.h>
const int maxn=1e4+5,Inf=2147483647;
int a[maxn];
int n;
void Read(){
  scanf("%d",&n);
  srand(time(0));
  for(int i=1;i<=n;++i)
    a[i]=rand()%10000;
}
void Print(){
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
}
void Insert_sort(int a[]){
  for(int i=2;i<=n;++i){
    for(int j=i;j>1 && a[j-1]>a[j];--j)
      std::swap(a[j],a[j-1]);
  }
}
void Solve(){
  Read();
  Insert_sort(a);
  Print();
}
int main(){
  Solve();
  return 0;
}

4. Shell排序

• 1959年Shell发明，第一个突破  O(n2) O ( n 2 )  的排序算法，是简单插入排序的改进版。它与插入排序的不一样之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

4.1 算法描述

1. 选择一个较大的增量，通常选gap=n/2，把下标为i,i+gap,i+2*gap+...+i+n/gap*gap分为一组，对同组的元素进行插入排序。

2. 减少增量为上一个增量的一半，继续操做1。

3. 重复以上操做，直到增量为1，此时序列变为有序。

4.2 动图演示

4.3 代码演示

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
      
 
     
    
      
    
    
    
     
     
              
     
     


   
     
   
   
   
    
    
             
    
    
#include <bits/stdc++.h>
const int maxn=1e4+5,Inf=2147483647;
int a[maxn];
int n;
void Read(){
  scanf("%d",&n);
  srand(time(0));
  for(int i=1;i<=n;++i)
    a[i]=rand()%10000;
}
void Print(){
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
}
void Shell_sort(){
  for(int d=n/2;d>0;d>>=1){//增量选择，逐渐缩小为原来一半
    for(int i=d+1;i<=n;++i){//对同组元素进行插入排序
      for(int j=i;j-d>0 && a[j]<a[j-d];j-=d)
        std::swap(a[j],a[j-d]);
    }
  }
}
void Solve(){
  Read();
  Shell_sort();
  Print();
}
int main(){
  Solve();
  return 0;
}

4.4 时间效率

• 希尔排序中对于增量序列的选择十分重要，直接影响到希尔排序的性能。咱们上面选择的增量序列{n/2,(n/2)/2...1}(希尔增量)，其最坏时间复杂度依然为 O(n2) O ( n 2 ) ，一些通过优化的增量序列如Hibbard通过复杂证实可以使得最坏时间复杂度为 O(n3/2) O ( n 3 / 2 ) 。

5. 归并排序

• 归并排序是创建在归并操做上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个很是典型的应用。将已有序的子序列合并，获得彻底有序的序列；即先使每一个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

5.1 算法描述

1. 把长度为n的输入序列分红两个长度为n/2的子序列；

2. 对这两个子序列分别采用归并排序；

3. 将两个排序好的子序列合并成一个最终的排序序列。

5.2 动图演示

5.3 代码实现

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
      
 
     
    
      
    
    
    
     
     
              
     
     


   
     
   
   
   
    
    
             
    
    
#include <bits/stdc++.h>
const int maxn=1e4+5,Inf=2147483647;
int a[maxn];
int n;
void Read(){
  scanf("%d",&n);
  srand(time(0));
  for(int i=1;i<=n;++i)
    a[i]=rand()%10000;
}
void Print(){
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
}
void Merge(int l,int mid,int r){//合并操做
  int i=l,j=mid+1,k=0;//i指向前面区间第一个元素，j指向后面区间第一元素
  int b[r-l+2]={0};//b存储合并的序列
  while(i<=mid && j<=r){//取两个序列前面的较小者
    if(a[i]<=a[j])b[++k]=a[i++];
    else b[++k]=a[j++];
  }//跳出循环两个序列中有一个为空
  while(i<=mid)//若比较完以后，第一个有序区仍有剩余
    b[++k]=a[i++];
  while(j<=r)//若比较完以后，第二个有序区仍有剩余
    b[++k]=a[j++];
  for(i=l,k=1;i<=r;++i,++k)//把合并后的排好序的序列拷贝到数组a[l,r]
    a[i]=b[k];
}
void Merge_sort(int l,int r){
  if(l<r){//把区间分红两部分
    int mid=l+(r-l)/2;
    Merge_sort(l,mid);//递归左区间
    Merge_sort(mid+1,r);//递归右区间
    Merge(l,mid,r);//合并左右两区间
  }
}
void Solve(){
  Read();
  Merge_sort(1,n);
  Print();
}
int main(){
  Solve();
  return 0;
}

5.4 时间效率

• 归并排序是一种稳定的排序方法。和选择排序同样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，由于始终都是 O(nlogn) O ( n l o g n ) 的时间复杂度。代价是须要额外的内存空间。

6. 快速排序

• 快速排序的基本思想：经过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另外一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.1 算法描述

1. 从数列中挑出一个元素，称为 基准（pivot）；

2. 从新排序数列，全部元素比基准值小的摆放在基准前面，全部元素比基准值大的摆在基准的后面（相同的数能够到任一边）。在这个分区退出以后，该基准就处于数列的中间位置。这个称为分区（partition）操做；

3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

6.2 动图演示

6.3 代码实现

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
      
 
     
   
     
   
   
   
    
    
             
    
    
#include <bits/stdc++.h>
const int maxn=1e4+5,Inf=2147483647;
int a[maxn];
int n;
void Read(){
  scanf("%d",&n);
  srand(time(0));
  for(int i=1;i<=n;++i)
    a[i]=rand()%10000;
}
void Print(){
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
}
void Quick_sort(int l,int r){
  if(l>=r)return;
  int i=l,j=r,base=a[l];//选左边界做为基准
  while(i<j){//做指针要小于右指针
    while(i<j && a[j]>base)--j;//先遍历右边界
    while(i<j && a[i]<base)++i; 
    if(i<j)std::swap(a[i],a[j]);
  }//跳出循环时i==j，此位置为基准最终位置
  std::swap(a[l],a[i]);
  Quick_sort(l,i-1);
  Quick_sort(i+1,r);
}
void Solve(){
  Read();
  Quick_sort(1,n);
  Print();
}
int main(){
  Solve();
  return 0;
}

7. 堆排序

• 堆排序 (Heapsort) 是指利用堆这种数据结构所设计的一种排序算法。

• 堆是一个近似彻底二叉树的结构，并同时知足堆的性质：即子结点的键值或索引老是小于（或者大于）它的父结点。

• 堆排序能够说是一种利用堆的概念来排序的选择排序。分为两种方法：

1. 大顶堆：每一个结点的值都大于或等于其子结点的值，在堆排序算法中用于升序排列；

2. 小顶堆：每一个结点的值都小于或等于其子结点的值，在堆排序算法中用于降序排列；

• 堆排序的平均时间复杂度为 Ο(nlogn)。

7.1 算法描述：

1. 建立一个堆

2. 把堆首（最大值）和堆尾互换；

3. 堆的大小减一，并向下调整堆使之知足堆的性质

4. 重复2,3直到只剩一个元素。

7.2 动图演示

7.3 代码实现

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
      
 
     
    
      
    
    
    
     
     
              
     
     


   
     
   
   
   
    
    
             
    
    
#include <cstdio>
#include <cstring>
const int maxn = 10000 + 5;
void swap(int &x,int &y){int t=x;x=y;y=t;}//交换函数
int Heap[maxn],siz=0;
void Push(int x){//向上调整
    Heap[++siz]=x;//把插入的元素x放在数组最后
    for(int i=siz;i/2>0 && Heap[i]>Heap[i/2];i=i/2)
        swap(Heap[i],Heap[i/2]);
}
void Pop(){//向下调整
    swap(Heap[siz],Heap[1]);siz--;//交换堆顶和堆底，而后直接弹掉堆底
    for(int i=1;2*i<=siz;i*=2){
        int j=2*i;//若是存在右儿子且右儿子大于左儿子j就指向右儿子
        if(j+1<=siz && Heap[j]<Heap[j+1])++j;
        if(Heap[i]<Heap[j])swap(Heap[i],Heap[j]);
        else break;
    }
}
void Solve(){
    int n;scanf("%d",&n);
    for(int i=1;i<=n;++i){//建堆
        int x;scanf("%d",&x);
        Push(x);
    }
    for(int i=1;i<=n;++i){//输出堆顶并删除，此乃降序
        printf("%d ",Heap[1]);Pop();
    }
    printf("\n");
    for(int i=1;i<=n;++i)//所有出堆后原数组为升序
        printf("%d ",Heap[i]);
}
int main(){
    Solve();
    return 0;
}

8. 计数排序

• 计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。做为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有肯定范围的整数。

8.1 算法描述

1. 找出待排序的数组中最大和最小的元素(做为数组的范围)；

2. 统计数组中每一个值为i的元素出现的次数，存入数组C的第i项；

3. 对全部的计数累加（从C中的第一个元素开始，每一项和前一项相加）；

4. 反向填充目标数组：将每一个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

8.2 动图演示

8.3 代码实现

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
      
 
     
    
      
    
    
    
     
     
              
     
     


   
     
   
   
   
    
    
             
    
    
#include <bits/stdc++.h>
const int maxn=1e5+5,Inf=2147483647;
int n,a[maxn],b[maxn];
void Read(){
    scanf("%d",&n);
    srand(time(0));
    for(int i=1;i<=n;++i)
        a[i]=rand()%100000;
}
void Print(){
    for(int i=1;i<=n;++i)
        printf("%d ",a[i]);
}
void Counting_sort(){
    int Min=Inf,Max=-Inf;
    for(int i=1;i<=n;++i){
        b[a[i]]++;//值当下标，并计算个数
        Min=std::min(Min,a[i]);//
        Max=std::max(Max,a[i]);
    }
    int cnt=0;
    for(int i=Min;i<=Max;++i)
        while(b[i])a[++cnt]=i,b[i]--;
}
void Solve(){
    Read();
    Counting_sort();
    Print();
}
int main(){
    Solve();
    return 0;
}

9. 桶排序

• 桶排序是将待排序集合中处于同一个值域的元素存入同一个桶中，也就是根据元素值特性将集合拆分为多个区域，则拆分后造成的多个桶，从值域上看是处于有序状态的。对每一个桶中元素进行排序，则全部桶中元素构成的集合是已排序的。

9.1 算法描

1. 设置一个定量的数组看成空桶子。

2. 寻访序列，而且把项目一个一个放到对应的桶子去。

3. 对每一个不是空的桶子进行排序。

4. 从不是空的桶子里把项目再放回原来的序列中。

9.2 动图演示

9.3 时间效率

• 桶排序最好状况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，由于其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

10. 基数排序

• 基数排序是按照低位先排序，而后收集；再按照高位排序，而后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

10.1 算法描述

1. 取得数组中的最大数，并取得位数；

2. arr为原始数组，从最低位开始取每一个位组成radix数组；

3. 对radix进行计数排序（利用计数排序适用于小范围数的特色）；

10.2 动图演示

代码实现

   
     
   
   
   
    
    
             
    
    

    
      
    
    
    
     
     
              
     
     
 
       
       
 
      
    
      
    
    
    
     
     
              
     
     
 
      
 
     
    
      
    
    
    
     
     
              
     
     


    
      
    
    
    
     
     
              
     
     
 
       
       
 
      
    
      
    
    
    
     
     
              
     
     

    
      
    
    
    
     
     
              
     
     
 
      

 
     
    
      
    
    
    
     
     
              
     
     
 
      
 
       
 
        
 
         
 
          
 
           
 
            
 
             
 
            
 
            
 
             
程序员值得收藏的精选11套后台登陆页面和管理页面模版
 
             
50份优秀Java求职者简历
 
             
SpringCloud先后端分离实战项目视频教程分享
 
             
2020年全网最全BAT笔试面试题打包分享
 
            
 
           
 
          
 
         
 
        
 
       
 
      
 
     
    
      
    
    
    
     
     
              
     
     
     

    
      
    
    
    
     
     
              
     
     


    
      
    
    
    
     
     
              
     
     
感谢点赞支持下哈 
    
      
    
    
    
     
     
              
     
     


    
      
    
    
    
     
     
              
     
     


   
     
   
   
   
    
    
             
    
    
#include <bits/stdc++.h>
const int maxn=1e4+5,Inf=2147483647;
int a[maxn];
int n;
void Read(){
  scanf("%d",&n);
  srand(time(0));
  for(int i=1;i<=n;++i)
    a[i]=rand()%10000;
}
void Print(){
  for(int i=1;i<=n;++i)
    printf("%d ",a[i]);
}
int Get_max(int a[],int n){//求数组的最大值
  int Max=a[1];
  for(int i=1;i<=n;++i)
    Max=std::max(Max,a[i]);
  return Max;
}
/*
 * 参数说明：
 * a -- 数组
 * n -- 数组长度
 * exp -- 指数。对数组a按照该指数进行排序。
 *
 * 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；
 * (01) 当exp=1表示按照"个位"对数组a进行排序
 * (02) 当exp=10表示按照"十位"对数组a进行排序
 * (03) 当exp=100表示按照"百位"对数组a进行排序
 * ...
 */
void Count_sort(int a[],int n,int exp){
  int b[n+5],buckets[10]={0};
    // b存储"被排序数据"的临时数组
  for(int i=1;i<=n;++i)// 将数据出现的次数存储在buckets[]中
    buckets[(a[i]/exp)%10]++;
  for(int i=1;i<10;++i)// 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在b[]中的位置。
    buckets[i]+=buckets[i-1];
  for(int i=n;i>0;--i){// 将数据存储到临时数组b[]中
    b[buckets[(a[i]/exp)%10]]=a[i];
    buckets[(a[i]/exp)%10]--;
  }
  for(int i=0;i<=n;++i)// 将排序好的数据赋值给a[]
    a[i]=b[i];
}
void Radix_sort(int a[],int n){
  int Max=Get_max(a,n);// 数组a中的最大值
  for(int i=1;Max/i>0;i*=10)// 从个位开始，对数组a按"指数"进行排序
    Count_sort(a,n,i);
}
void Solve(){
  Read();
  Radix_sort(a,n);
  Print();
}
int main(){
  Solve();
  return 0;
}

本文分享自微信公众号 - java1234（gh_27ed55ecb177）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。