常见排序算法总结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 }

 

以上是常见的排序,望大家轻喷。(狗头保命)

你可能感兴趣的:(常见排序算法总结C&C++)