经典排序算法详解-优快云博客

本文深入讲解了冒泡、选择、插入等经典排序算法，并对比了快速、归并、堆排序等高级排序方法，还介绍了计数、基数排序等线性时间复杂度的排序算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

冒泡排序

#include<iostream>  
#include<vector>
using namespace std;  
int main(){   
    int num;
    vector<int>a;
    int i = 0;
    while (cin >> num){ 
         a.push_back(num);
         i++;
         if (cin.get() == '\n')   //遇到回车，终止
             break; 
         }
    int e,f,temp；   
    for(e=0;e<i;e++)
        for(f=0;f<i-e-1;f++){
           if(a[f]>a[f+1]){
               temp=a[f];
               a[f]=a[f+1];
               a[f+1]=temp;
           }
        }
    for(int j=0;j<i;j++){  
        cout<<"a["<<j<<"]:"<<a[j]<<endl;  
    }  
}

时间复杂度O(N^2)

选择排序

#include<iostream>  
#include<vector>
using namespace std;  
int main()  
{   int num;
    vector<int>arr;
    int n = 0;//n表示输入个数
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回车，终止
            break;             
    }
    int i,j,min,now;//now表示记录最小值的位置，min表示最小值  
    for(i=0;i<n-1;i++){
        min=arr[i];
        now=i;
        for(j=i+1;j<n;j++){
           if(min>arr[j]){
              min=arr[j];
              now=j;
           }
        }
        arr[now]=arr[i];
        arr[i]=min;
    }
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}

时间复杂度O(N^2)
思路：一列数，选出最小值，放在首位。剩下数，选出最小值，放在次位，依次类推。

插入排序

#include<iostream>  
#include<vector>
using namespace std;  
int i,j,k,insert,now;//now表示记录插入的位置，insert表示插入值 
void select(vector<int> &arr,int &n)//利用引用实现vector变量数值传递
{
    for(i=0;i<n;i++){
        insert=arr[i];
        for(j=0;j<i;j++){  //寻找插入位置
           if(insert<=arr[j]){
              break;
           }
        }
        now=j;
        for(k=i;k>now;k--){  //完成插入过程
            arr[k]=arr[k-1];
        }
        arr[now]=insert;
    } 
}
void out(vector<int> arr,int n)
{
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  

}

int main()  
{   int num;
    vector<int>arr;
    int n = 0;//n表示输入个数
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回车，终止
            break;             
    }
    select(arr,n); 
    out(arr,n);
}

时间复杂度O(N^2)
1.第1 2数比较，排序。
2.第3 个数依此和2 1比较排序。
3.第4个数依此和3 2 1比较，排序，以此类推。

以上三个经典算法，实现复杂度均为O(N^2)。下介绍时间复杂度为O(N*logN)的算法。

归并排序
这里写图片描述
看作4个组，组内排序，得到最大长度为2的有序区间。

看作2个组，组内排序，得到最大长度为4的有序区间。

最后

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void merge(vector<int> &arr,int low,int mid,int high){
    int i=low; //i是第一段序列的下标
    int j=mid+1; //j是第二段序列的下标
    int k=0; //k是临时存放合并序列的下标
    int *b=new int[high-low+1]; //b是临时合并序列
    while(i <= mid && j <= high){// 判断第一段和第二段取出的数哪个更小，将其存入合并序列，并继续向下扫描
        if(arr[i] <= arr[j]){
            b[k] = arr[i];
            i++;
            k++;
        } 
        else{
            b[k] = arr[j];
            j++;
            k++;
        }
    }
    while(i<=mid){ //若第一段序列还没扫描完，将其全部复制到合并序列
        b[k] = arr[i];
        i++;
        k++;
    } 
    while(j<=high){ //若第二段序列还没扫描完，将其全部复制到合并序列
        b[k]=arr[j];
        j++;
        k++;
    }
    for(k=0,i=low;i<=high;i++,k++){ //将合并序列复制到原始序列中
        arr[i]=b[k];
    }
}

void mergePass(vector<int> &arr,int gap,int n){
    int i=0;    
    for(i=0; i+2*gap-1<n; i=i+2*gap){ //归并gap长度的两个相邻子表
        merge(arr, i, i+gap-1, i+2*gap-1);
    }   
    if (i+gap-1<n){ //余下两个子表，后者长度小于gap,若大于n说明就一个子表，不用动
        merge(arr, i, i+gap-1, n-1);
    }
}

void select(vector<int> &arr, int n){
    for(int gap=1;gap<n;gap=2*gap){
        mergePass(arr, gap, n);
    }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示输入个数
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回车，终止
            break;             
    }
    select(arr,n); 
    out(arr,n);
}

快速排序
这里写图片描述

一次划分过程简述
1.把随机选中数（3为例）放到最后（与最后一位交换）
这里写图片描述
2.设计一个小于等于区间（在最前）

3.下从左到右遍历所有数，发现比3小的数，同最靠近小于等于区间的数交换，再使区间右扩一个位置。

这里写图片描述
4.遍历完成，将3同区间外的数交换，完成划分

以上为一次完整划分过程，它的时间复杂度为O(N)

#include<iostream>  
#include<vector>
#include<stdlib.h>
using namespace std;  

void out(vector<int> arr,int n){ //数组输出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}

void quicksort(vector<int> &arr, int left,int right){//
    if(left<right){ //表明分的不够细，需要快速排序
      int now=(rand()%(right-left+1))+left;//生成左右之间的一个随机数：
                                           //要取得[a,b)的随机整数，使用(rand()%(b-a))+a; 
                                           //要取得[a,b]的随机整数，使用(rand()%(b-a+1))+a; 
                                           //要取得(a,b]的随机整数，使用(rand()%(b-a))+a+1;
      int temp;
      temp=arr[right];
      arr[right]=arr[now];
      arr[now]=temp;           //把选择节点移植数组末尾
      int k=left;
      for(int i=left;i<right;i++){
          if(arr[i]<arr[right]){  //若发现比选择节点小的值，放置数组的首部，并移动节点所需放置的位置
             temp=arr[k];
             arr[k]=arr[i];
             arr[i]=temp;
             k++;
          }
      }
      temp=arr[k];
      arr[k]=arr[right];
      arr[right]=temp;           //把选择节点放在对应的位置，此时其左边数都比其小，右边数都比其大。
      quicksort(arr,left,k-1);   //递归，处理选择节点左边的数组
      quicksort(arr,k+1,right);  //递归，处理选择节点右边的数组
    }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示输入个数
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回车，终止
            break;             
    }
    quicksort(arr,0,n-1); //快速排序
    out(arr,n);  //输出数组
}

堆排序
1.建堆
这里写图片描述
堆顶为整个排列最大值。
2.把堆顶和堆的最后一个数交换

然后把最大值脱离堆结构

脱离值放到最后，作为有序部分。

3.下把n-1大小的堆从堆顶进行大根堆调整（这是啥？个人理解是依此把每个子树的最大值放在根节点的位置），将最大值调至堆顶。再把堆顶和堆的最后一个数交换。递归实现，完成排序。

希尔排序
是插入排序的改良算法，插入排序步长为1，希尔排序步长可调（从大到小）。
下举例（步长为3）
这里写图片描述

6同1（三位前）比较，6 1交换
变为
1 5 3 6 8 7 2 4
下8同5（三位前）比较，8 5不交换
下7同3（三位前）比较，7 3不交换
下2同6（三位前）比较，2 6交换
1 5 3 2 8 7 6 4
2再同1（三位前）比较，2 1不交换
下4同8（三位前）比较，4 8交换
1 5 3 2 4 7 6 8
4再同5（三位前）比较，4 5交换
1 4 3 2 5 7 6 8
这里写图片描述

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){ //数组输出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void hill(vector<int> &arr, int i,int step){//
    int temp;        
    if(arr[i]<arr[i-step]){
        temp=arr[i];
        arr[i]=arr[i-step];
        arr[i-step]=temp;           
        if(i-2*step>0){   //判断是否需要向前继续交换
           hill(arr,i-step,step);    
        }
    }
}
void hillsort(vector<int> &arr, int legth,int step){//
    if(step>=1){
        for(int i=step;i<legth;i++){
            hill(arr,i,step);      
        }   
        step--;   //步长逐级降低
        hillsort(arr,legth,step);   //递归希尔排序
    }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示输入个数
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回车，终止
            break;             
    }
    int step=3; //步长的选择
    hillsort(arr,n,step); //希尔排序
    out(arr,n);  //输出数组
}

希尔排序的关键：步长选择。
选择越优，时间复杂度越低；选择越劣，时间复杂度趋近于O(N^2)

下介绍时间复杂度为O(N)的算法，这类算法不是基于比较的排序算法，思想来自桶排序。

计数排序
例子：员工身高排序，建立200个木桶，把人放进去。所有员工进桶后，各个桶依此倒出员工。
这里写图片描述

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){ //数组输出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void countsort(vector<int> &arr, int length){//
    int b[10]={};  //放数用的桶，可用来记录0~9的数量
    int z=0;
    int temp;
    for(int i=0;i<length;i++){
        b[arr[i]]++;    //把数放在桶里
    }
    for(int j=0;j<10;j++){  //从桶中倒数
        if(b[j]!=0){
           temp=b[j];
           for(int k=1;k<=temp;k++){
               arr[z]=j;
               z++;
           }
        }
    }
}
int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示输入个数
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回车，终止
            break;             
    }
    countsort(arr,n); //计数排序
    out(arr,n);  //输出数组
}

基数排序
例：023 014 101 072 084 011
准备0到9，十个桶
根据个位数值选择进桶
这里写图片描述

然后依此倒出所有数
101 011 072 023 014 084
再十位倒桶
再倒出
……
最后倒出，完成排序。

#include<iostream>  
#include<vector>
using namespace std;  

void out(vector<int> arr,int n){ //数组输出
    for(int k=0;k<n;k++){  
        cout<<"arr["<<k<<"]:"<<arr[k]<<endl;  
    }  
}
void basenumbersort(vector<int> &arr, int length){//三次进出桶，可以简化成一个函数的，这次先分开写，便于理解
    int b[10][100]={};  //放数用的桶，可用来记录0~9的数量
    int z=0;
    int temp;
    for(int i=0;i<length;i++){
        int temp1=arr[i]%10;
        b[temp1][0]++;
        b[temp1][b[temp1][0]]=arr[i];   //把数按个位值放在桶里
    }
    for(int j=0;j<10;j++){  //从桶中倒数
        if(b[j][0]!=0){
           temp=b[j][0];
           for(int k=1;k<=temp;k++){
               arr[z]=b[j][k];
               z++;
           }
        }
    }
    z=0;                           //初始化
    for(int i=0;i<10;i++)
        for(int j=0;j<100;j++){
            b[i][j]=0;
        }

    for(int i=0;i<length;i++){
        int temp1=(arr[i]/10)%10;
        b[temp1][0]++;
        b[temp1][b[temp1][0]]=arr[i];   //把数按十位值放在桶里
    }
    for(int j=0;j<10;j++){  //从桶中倒数
        if(b[j][0]!=0){
           temp=b[j][0];
           for(int k=1;k<=temp;k++){
               arr[z]=b[j][k];
               z++;
           }
        }
    }
    z=0;//初始化
    for(int i=0;i<10;i++)
        for(int j=0;j<100;j++){
            b[i][j]=0;
        }

    for(int i=0;i<length;i++){
        int temp1=arr[i]/100;
        b[temp1][0]++;
        b[temp1][b[temp1][0]]=arr[i];   //把数按百位值放在桶里
    }
    for(int j=0;j<10;j++){  //从桶中倒数
        if(b[j][0]!=0){
           temp=b[j][0];
           for(int k=1;k<=temp;k++){
               arr[z]=b[j][k];
               z++;
           }
        }
    }
    z=0;//初始化
    for(int i=0;i<10;i++)
        for(int j=0;j<100;j++){
            b[i][j]=0;
        }
}

int main(){
    int num;
    vector<int>arr;
    int n = 0;//n表示输入个数
    while (cin >> num){ 
         arr.push_back(num);
         n++;
         if(cin.get() == '\n')   //遇到回车，终止
            break;             
    }
    basenumbersort(arr,n); //计数排序
    out(arr,n);  //输出数组
}

排序(1)