常见排序算法总结C&C++

常见排序主要有以下四种：

1.交换排序

2.选择排序

3.插入排序

4.归并排序

（以下代码基本都有输出每步排序结果）

 

一.交换排序

交换排序主要是冒泡排序和快排

1.冒泡排序

基本方法：

设待排序对象序列中的对象 个数为 n。

最多作 n-1 趟排序。在第 i 趟中顺次两两 比较r[j-1].Key和r[j].Key，j = i, i+1, ……, n-i-1。

如果发生逆序，则交换r[j-1]和r[j]。

流程：

（1）对数组中各个数字，一次比较相邻两个

（2）如果前面大于后面，就交换这两个数据

（3）再用同样的方法继续排，直到外层循环排完

 

 

#include
#include
#include
using namespace std;
void BubbleSort(int a[],int len)
{
    int t;
    for (int i = 0; i < len-1; i++)
    {
        for (int j = len-1; j>i; j--)
        {
            if (a[j]1])         //比较相邻两个，前大于后，交换
            {
                t=a[j-1];
                a[j-1]=a[j];
                a[j]=t;
            }
        }
        cout<<"Sort results in"<1<<" step :";  //输出每一步排序结果
        for (int k = 0; k " ";
        cout<<endl;
    }
}int main()
{
    int array1[10];
    srand(time(NULL));
    cout<<"Array1 before sorting:"<<endl;
    for (int i = 0; i < 10; i++)       //利用随机数作为数组输入
    {
        array1[i]=rand()/1000;
        cout<" ";
    }
    cout<<endl;
    BubbleSort(array1,10);
    cout<<"Array1 after sorting:"<<endl;
    for (int i = 0; i < 10; i++) cout<" ";
    cout<<endl;return 0;
}

 

 

2.快速排序

基本思想：

任取待排序对象序列中的某个对象 (例如取第一个对象) 作为枢轴(pivot)，

按照该对象的关键字大小，将整个对象序列划分为左右两个子序列：

– 左侧子序列中所有对象的关键字都小于或等于枢轴对象的 关键字

– 右侧子序列中所有对象的关键字都大于枢轴对象的关键字 

枢轴对象则排在这两个子序列中间(这也是该对象最终应安放 的位置)。

流程：

（1）首先设定一个分界值，通过分界值将数组分成左右两部分。

（2）将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。

（3）左右两个部分重复上述排序。

（详细解释见代码）

#include
#include
#include
using namespace std;
void QuickSort(int *a,int left,int right)
{
    int rt,lt,t,base;
    rt=right;                           //rt为基准分组后的左半部分上边界
    lt=left;                            //lt为基准分组后的右半部分的下边界
    base=a[left];
/*这里定义分界值，这个分界值定在哪里都是可以的，定在中间更为直观，若定在其他地方，手动排一下就知道，边界值会换到中间去，和定在中间一个样*/
    while (lt < rt)
    {
        while(a[lt] < base) lt++;       //从左边开始寻找大于分界值的值
        while(a[rt] > base) rt--;       //从右边开始寻找小于边界值的值
        if(lt < rt)
        { /*lt小于rt，就交换这两个的值，lt与rt必不会在边界值同一侧，
        手动按照算法排一下就知道，lt或rt到了边界值的时候就会停下来，交换的时候就会把边界值换到中间去了*/
            t = a[lt] ;
            a[lt] = a[rt] ;
            a[rt] = t ;
            lt++;
            rt--;
        }
    }
    while(a[lt]<base) lt++; //因为右半部分可能还到不了下边界，所以需要继续递增
    while(a[rt]>base) rt--;//因为左半部分可能还到不了上界，所以需要继续递减
    if(lt == rt) lt++;     //此处为了避免两个边界模糊不清
    if( left < rt ) QuickSort(a,left,rt); //递归对左半部分快排
    if( right > lt) QuickSort(a,lt,right); //递归对右半部分快排
    
}
int main()
{
    srand(time(NULL));
    int n;
    cout<<"Please cin the size of array:"<//输入数组的大小
    cin>>n;
    int a[n];
    cout<<"Array before sorting is:"<<endl;
    for (int i = 0; i < n; i++)
    {
        a[i]=rand()/1000;              //随机数作为数组输入
        cout<" ";
    }
    cout<<endl;
    QuickSort(a,0,n-1);
    cout<<"Array after sorting is:"<<endl;
    for (int i = 0; i < n; i++) cout<" ";
    cout<<endl;
    return 0;
}

 

二.选择排序

常见的选择排序有简单的选择排序和堆排序

1.简单的选择排序

流程：

（1）先从原始数组选择一个最小数据和第一个位置交换

（2）剩下的n-1个数据选择最小的和第二个位置交换

（3）不断重复直到最后执行完成

#include
#include
#include
using namespace std;
void SelectionSort(int a[],int len)
{
    int k,t;
    for (int i = 0; i < len-1; i++)
    {
        k=i;
        for (int j = i+1; j < len; j++)  //选择第i+1个小的数据
        {
            if (a[j]j;
        }
        if (k!=i)                      //选好后就可以交换了
        {
            t=a[k];
            a[k]=a[i];
            a[i]=t;
        }
        cout<<"Sort Result in"<1<<"step:"<<endl;
        for (int k = 0; k < len; k++) cout<" ";
        cout<<endl;
        
    }
    
}
int main()
{
    int array[10];
    srand(time(NULL));
    cout<<"Array before sorting:"<<endl;
    for (int i = 0; i < 10; i++)       //随机数作为数组输入
    {
        array[i]=rand()/1000;
        cout<" ";
    }
    cout<<endl;
    SelectionSort(array,10);
    cout<<"Array after sorting:"<<endl;
    for (int i = 0; i < 10; i++) cout<" ";
    cout<<endl;
    return 0;
}

 

2.堆排序

堆排序关键是构造堆结构。这是一个完全二叉树结构。在这个树中每个节点对应原始数据一个记录。每个节点满足以下条件：

（1）若按照从小到大排序，要求非叶节点的数据大于等于其左右子节点的数据

（2）若按照从大到小排序，要求非叶节点的数据要小于等于其左右子节点的数据

可以看出，这只规定父节点和子节点的数据之间必须满足的大小关系。

完整的堆排序需要反复经过两个步骤：

（1）构造堆结构，

（2）堆排序输出。

下面介绍如何构造堆结构：

由完全二叉树的下层向上层逐层对父子节点的数据进行比较，使父节点的数据大于等于子节点的数据。（最小堆）

这里需要用到筛选运算不断调整，直到节点满足堆结构为止：

（1）先将原始数据排成一个二叉树

（2）对最后一个非叶节点进行筛运算。

*筛运算：比较左右子树，最大值放右子树，比较右子树与非叶节点，最大值放非叶节点。（比较过程中并非直接等，而是值互换）

（3）对倒数第二个非叶节点进行筛运算，

（4）一直重复，直到根节点进行筛运算为止。（若根节点的值被互换了，那么就要对互换的节点进行筛运算，一直下去）这时就形成了堆结构。

形成了堆结构，接下来就是堆排序输出（现在是按照从小到大的方式排序）：

（1）输出根节点，把最后一个结点的数放到根节点

（2）重新构造堆结构

（3）重复（1）（2）步，直到全部输出。

 

（这里并不构建树，直接对数组操作，关于树如果不理解的可以自己依据完全二叉树画法，首元素为树根，依次往下得出树结构，详细见代码及代码注释）

#include
#include
#include
using namespace std;
void HeapSort(int a[],int n)
{
    int t;
    for (int i = n/2-1; i >=0; i--)   //第n/2-1个节点为止，都是非叶子节点
    {
        while (2*i+1//节点2*i+1是i的子树
        {
            int j=2*i+1;
            if (j+1//判定是否为一个子树
            {                        //不是一个子树
                if(a[j]1]) j++; //判定哪个子树大，较大的子树与父节点比较
            }
            
            if (a[i]//与父节点比较
            {
                t=a[i];             //交换
                a[i]=a[j];
                a[j]=t;
                t=j;                //因为与父节点的值交换了，所以需要对交换的节点重新进行筛选运算
            }
            else break;
        }
        
    }
    cout<<"The original heap structure is:"<//输出原始堆结构
    for(int i=0;i" ";
    cout<<endl;
    int i;
    for (i = n-1; i >=0; i--)                   //开始排序
    {
        t=a[0];                                 //交换根节点的值到数组最后
        a[0]=a[i];
        a[i]=t;
        int k=0;
        while (2*k+1//开始重新构造堆结构，因为从i开始，所以到i截止
        {
            int j=2*k+1;                    //接下来与构造堆结构同
            if (j+1<i)
            {
                if(a[j]1]) j++;
            }
            if (a[k]<a[j])
            {
                t=a[k];
                a[k]=a[j];
                a[j]=t;
                k=j;
            }
            else break;
        }
        cout<<"Array after "<"step:";       //输出每一步排序
        for (int c = 0; c < n; c++) cout<" ";
        cout<<endl;
            
    }
    
    
}
int main()
{
    srand(time(NULL));                  //随机数作为数组输入
    int n;
    cout<<"Please cin the size of array:"<<endl;
    cin>>n;
    int a[n];
    cout<<"Array before sorting:"<<endl;
    for (int i = 0; i < n; i++)
    {
        a[i]=rand()/1000;
        cout<" ";
    }
    cout<<endl;
    HeapSort(a,n);
    cout<<"Array after sorting:"<<endl;        
    for(int i=0;i" ";
    cout<<endl;
    return 0;
}

 

三.插入排序

插入排序：通过对未排序的数据逐个插入合适的位置而完成排序工作

常见的插入排序有简单的插入排序和Shell排序

1.直接的插入排序

直接插入排序的基本思想是：

当插入第i (i ≥ 1) 个对象时，前面 的v[0], v[1], …, v[i-1]已经排好序。

这时，用v[i]的关键字与v[i1], v[i-2], …的关键字顺序进行比较，

找到插入位置即将v[i]插 入，原来位置上之后的所有对象依次向后顺移。

流程：

（1）先对数组前两个数据进行从小到大排序

（2）将第三个数据与前两个数据比较，将第三个数据插入合适的位置

（3）将第四个数据插入已排序好的前三个数据中

（4）不断重复，直到把最后一个数据插入合适的位置

（详细见代码及注释）

#include
#include
#include
using namespace std;
void InsertionSort(int a[],int len)
{
    int t;
    for (int i = 0; i < len; i++)
    {
        t=a[i];  //对第i个数进行标记（从零开始算，下同）
        int j=i-1; //从第i-1个数倒着回去找位置（第i-1个数前面的都从小到大排好了）
        while (j>=0&&t//找位置，小于第j个数继续找，而比较过的数就往后退留出空位置
        {//由于我们标记了第i个数，所以我们比较过的数往后退的时候可以留出一个位置，因为第i个数位置空出来了
            a[j+1]=a[j];
            j--;
        }
        a[j+1]=t;
        cout<<"Sort result after"<1<<"step:";
        for(int k=0;k" ";
        cout<<endl;
    }
}
int main()
{
    int a[10];
    srand(time(NULL));
    cout<<"Array before sorting:"<//随机数作为数组输入
    for (int i = 0; i < 10; i++)
    {
        a[i]=rand()/1000;
        cout<" ";
    }
    cout<<endl;
    InsertionSort(a,10);
    cout<<"Array after sort:"<<endl;
    for (int i = 0; i < 10; i++) cout<" ";
    cout<<endl;
    return 0;
    
}

 

2.Shell排序 （处理数据量比较大的时候的插入排序）

基本思想：

先将整个待排对象序列按照一定间隔分 割成为若干子序列，

分别进行直接插入排序，然后缩小间隔， 对整个对象序列重复以上的划分子序列和分别排序工作，

直到 最后间隔为1，此时整个对象序列已 “基本有序”，进行最后 一次直接插入排序。

流程：

（1）将n个元素数组分成n/2个数字序列，第一个数据和第n/2个数据为一对，等等，以此类推

         比如说 8 6 5 4 2 1 9 7

         就分为数字序列 8 6 5 4 以及 2 1 9 7 

         那么8 和 2就是一个数对

（2）一次循环使每一个数对排列好顺序（假设从小到大）

         依据上述，排序好后就是 2 1 5 4 和 8 6 9 7（2小于8，交换，1小于6，交换，9大于5，7大于4所以不用交换）

（3）变成n/4个数对，再次排序。

         （数字序列就成为 2 1 ，5 4，8 6，9 7，这个时候有三次比较，设四个序列分别为a,b,c,d,那么此时b与a比较，然后c与b比较，然后d与c比较，后面以此类推 ）

（4）不断重复上述过程，随着序列减少直至最后变为1个（此时就成为插入排序了），完成排序。

（详细见代码及注释）

#include
#include
#include
using namespace std;
void ShellSort(int *a,int len)
{
    int x,t,j;
    for (int r = len/2; r >=1 ; r/=2)    //外层循环分序列
    {
        for (int i = r; i < len; i++)    
        {//内层循环设置一定间距r，分别比较对应元素，当r=1时，这个时候就为插入排序，数组量大时这时效率比较高。
            t=a[i];
            j=i-r;
            while (j>=0&&t<a[j])
            {
                a[j+r]=a[j];
                j-=r;
            }
            a[j+r]=t;
            x++;
            cout<<"Sort result after "<" step ";              //输出每一步排序结果
            for (int k = 0; k < len; k++) cout<" ";
            cout<<endl;
        }
        
    }
    
}
int main()
{
    srand(time(NULL));
    int n;
    cout<<"Please cin the size of array:"<//输入数组的大小
    cin>>n;
    int a[n];
    cout<<"Array before sorting:"<<endl;
    for (int i = 0; i < n; i++)            //利用随机数作为数组输入
    {
        a[i]=rand()/1000;
        cout<" ";
    }
    cout<<endl;
    ShellSort(a,n);
    cout<<"Array after sorting:"<//输出排序后的数组
    for (int i = 0; i < n; i++) cout<" ";
    cout<<endl;
    return 0; 
    
}

 

四.归并排序

一个待排序的原始数据序列进行排序归并排序的基本思路：

（1）将n个待排序数据看成n个有序子表，这时候无所谓有序无序。

（2）将他们依次两两合并，得到长度为2的有序子表

（3）再两两合并，得到长度为4的有序子表。不能合并的留到下次一起合并

（4）重复上述步骤，直到表长度为n

eg.（1）待排序数据24 30 29 3 2 21 3 8 ，这里就是8个有序子表，无所谓有序无序

     （2）两两合并，对子表排序，得到 24 30 ，3  29，2  21，3  8四个长度为2的有序子表

     （3）再两两合并，得到长度为4的有序子表 3 24 29 30，2  3  8  21

     （4）再合并得到 2 3 3 8 21 24 29 30

详细见代码及注释（非递归实现）

#include
#include
#include
using namespace std;
void MergeOne(int *a,int *p,int n,int len)
{
    int i,j,k,begin,edge;        //i,j分别代表合并前左子表和右子表的初始下标，k表示要赋值的数组的下标
    begin=0;                     //begin代表合并的两组子表的初下标
    while(begin+len<n)
    {
        edge=begin+2*len-1;    //edge代表合并后的两组子表的末下标
        if(edge>=n) edge=n-1;  //因为有可能并不能全部一次性合并，有奇数，这时就会剩下未合并的
        i=begin;               
        k=begin;
        j=begin+len;
        while (i//当子表下标都在合并范围内的时候
        {
            if(a[i]//哪个小，哪个就赋值到数组
            else p[k++]=a[j++];
        }
        while(i//如果左边子表剩下了，就把剩下的都放进数组
        while(j<=edge) p[k++]=a[j++];    //如果右子表剩下了，就把剩下的放进数组
        begin=edge+1;                    //继续合并下两组子表
    }
    if(beginfor(;begin//未合并的，单个的，先放进数组
}
void MergeSort(int *a,int n)
{
    int *p=new int [n];   //合并的数组
    int len=1;           //子表长度
    int f=0;             //标记，以a为初始数组还是以p为初始数组
    int count=0;        //记录合并步骤
    while (len//合并后子表长度小于n时，可以继续合并
    {
        if(f==1) MergeOne(p,a,n,len); //以p为初始数组
        else MergeOne(a,p,n,len);     //以a为初始数组
        f=1-f;                        //切换
        len*=2;                       //合并一次，子表长度double
        count++;                      //合并次数递增
        cout<" step:";
        //输出每步结果
        if(f) for (int i = 0; i < n; i++) cout<" "; 
        else for (int i = 0; i < n; i++) cout<" ";
        cout<<endl;
        
    }
    if (f)
    {//判断最后一次是否以a为初始数组，如果是的话，就要把p的值全部赋值给a
        for(int i=0;ip[i];   
    }
    delete []p;
}
int main()
{
    srand(time(NULL));
    cout<<"Please cin the size of array:"<<endl;
    int n;
    cin>>n;
    int a[n];
    cout<<"Array before sorting:"<<endl;
    for (int i = 0; i < n; i++)
    {
        a[i]=rand()/1000;
        cout<" ";
    }
    cout<<endl;
    MergeSort(a,n);
    cout<<"Array after sorting:"<<endl;
    for(int i=0;i" ";
    cout<<endl;
    return 0;
}

归并算法递归实现如下，详情见代码及注释（需要手动输入数组大小及数组的值）

递归主要思想是分治：

思路：（1）先将数组划分为一个个块，直到不能再划分为止（分）

           （2）对划分的数组进行排序

需要：（1）一个临时变量数组p，存储每次归并后的值，然后赋给a（这个时候p处理归并数据下标的范围和a的下标范围一致）

           （2）一个函数，用来分（划分下标范围）

           （3）一个函数，用来治（将两组数据归并，归并后即为排序）

详细请见代码及注释

 1 #include
 2 using namespace std;
 3 void Mergesort(int a[],int begin,int mid,int end,int n,int p[])  //归并排序
 4 {
 5     int i=begin,j=mid+1,k=i;    
 6     //i是左分组起始下标，mid是分组边界也是i的上界，j是右分组的左边界，j上界为end，k为临时储存数组p的下标
 7     while (i<=mid&&j<=end) //开始对两个分组进行归并
 8     {
 9         if (a[i]//分组中小的放先放进p，然后递增下标
10         else p[k++]=a[j++];
11     }  //循环结束时，左右两分组必有一个没有全部并到临时储存数组p
12     while(i<=mid) p[k++]=a[i++];    //这时我们需要检查，并把没有并的放到p里面
13     while(j<=end) p[k++]=a[j++];
14     for (int i = 0; i < (end-begin+1); i++) a[i+begin]=p[i+begin]; //把归并好的放到a里
15     for(int i=0;i" ";   //输出每一步的归并结果
16     cout<<endl;
17 }
18 
19 void Divide_Conquer(int a[],int begin,int end,int n,int p[]) //递归分治
20 {
21     if (begin<end)
22     {
23         int mid=begin+(end-begin)/2;     //定一个分治的边界
24         Divide_Conquer(a,begin,mid,n,p); //左分
25         Divide_Conquer(a,mid+1,end,n,p); //右分
26         Mergesort(a,begin,mid,end,n,p);  //治，对分的数据进行排序
27     }
28     
29 }
30 
31 int main()
32 {
33     int n;
34     cin>>n;                          //输入数组大小
35     int a[n],p[n];                   //a[n]为数组，p[n]为临时数组
36     for(int i=0;i>a[i];  //输入数组数值
37     Divide_Conquer(a,0,n-1,n,p);     //开始分治，归并
38     //cout<<"Array after sort:"<39     //for(int i=0;i//输出归并的值
40     //cout<
41     return 0;
42 }

 

以上是常见的排序，望大家轻喷。（狗头保命）