有趣算法之合并排序

2.7 合并排序

20200926

参考链接：

https://blog.csdn.net/li528405176/article/details/86615003

https://blog.csdn.net/qq_38737992/article/details/77937868?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param

https://www.cnblogs.com/chengxiao/p/6194356.html

 

 

1.问题描述

 

合并排序是建立在归并操作上的一种有效的排序算法。基本思想是：将待排序元素分成大小大致相同的两个子集合，然后在对子集和进行不断地划分，直至子集合中元素不可划分为止，然后对同一等级的两个子集合对应元素进行排序，最终将拍还需的子集合合并成排好序的子集合。

 

 

2.问题分析

 

以下内容引自360百科：

归并过程为:比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1;否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。

具体算法我们通过几张图片来理解一下吧！

图片来自：https://www.cnblogs.com/chengxiao/p/6194356.html

 

2.1.分而治之

 

如下图，

蓝色部分：将若干个元素首先拆分成两个子集合，然后在对子集合进行拆分，直至子集合不可再划分为止。

绿色部分：将拆分时对应层次的子集合进行不断地进行两两排序，整合成一个新的子集合，新的子集合按照这样在进行整合，依次不断往复。至于子集合怎么两两排序咱接着往下看！

 

 

2.2.合并

如下图，以上一步最后一个两两合并为例。（绿色为左集合，红色为右集合）

绿色的元素1与红色的元素1进行比较，红元素1小，放置临时集合temp1位置中，然后将红元素的下标右移则为元素2，用绿元素1和红元素2进行比较，去较小元素放置临时集合temp2位置中。依次往复比较，最终得到新的集合！

 

最后，咱来看一张整体的动图吧！

 

再来一张，下面这张基本上就是递归形式代码的图形化演示：

来源于：https://www.runoob.com/w3cnote/merge-sort.html

 

 

3.代码实现

3.1.递归形式：

 

// 2_7_test.cpp : Defines the entry point for the console application.
//

#include <stdio.h>
void Merge(int a[],int l,int m,int r,int tem[]) //对数组a 区间 a[l] 到 a[r] 排序
{
    int p1 = l, p2 = m+1;
    int pb = 0;
    while(p1 <= m && p2 <= r) //对左右两个数组进行排序
    {
        if(a[p1] < a[p2]) //如果左边的 < 右边对应的
            tem[pb++] = a[p1++];
        else
            tem[pb++] = a[p2++];
    }
 
    while(p1 <= m) //左边还有剩余
    {
        tem[pb++] = a[p1++];
    }
 
    while(p2 <= r) //右边还有剩余
    {
        tem[pb++] = a[p2++];
    }
 
    for(int i=0; i<r-l+1; i++) //临时数组中的元素copy到数组a中
        a[l+i] = tem[i];
}
void Mergesort(int a[],int l,int r,int tmp[])
//
{
    if(l < r)
    {
        int m = l+ (r-l)/2;
        Mergesort(a,l,m,tmp);  //对左区间归并
        Mergesort(a,m+1,r,tmp); // 对右区间归并
        Merge(a,l,m,r,tmp); //对数组a 区间 a[s] 到 a[e] 排序
    }
}
int a[8] = {13, 27, 19, 12, 2, 8, 30, 89}; // 样例数列
int b[10]; // 中间变量数组，无实际意义。
int main(int argc, char* argv[])
{
    int size = sizeof(a)/sizeof(int);
    int i=0;
    printf("原数组元素为：\n");
    for(i=0; i<size; ++i)
        printf("%d ,",a[i]);  // 输出数组 a
    printf("\n");

    Mergesort(a,0,size-1,b); // 对 a[] 归并排序
 
    for(i=0; i<size; ++i)
        printf("%d ,",a[i]);  // 输出数组 a
    printf("\n");

    return 0;
}

 

运行结果：

 

 

3.2.非递归形式

如下图为递归形式的排序图，

 

 

 

源码链接：https://blog.csdn.net/qq_41681241/article/details/88692972

关于代码的一下解释，我在源码中做了一些标注，如有问题，欢迎评论区交流！

// merge_sort01.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

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


void merge(vector<int>&ls, vector<int>&tmp, int l, int m, int r) {
    //合并ls[l:m]和c[m+1:r]到tmp[l:r]
    int left = l ;
    int k = l ;
    int mid = m+1 ;
    //将当前段的元素按从小到大的顺序转移到tmp数组中相应位置
    while(left<=m&&mid<=r) {
        
        if(ls[left] > ls[mid]) {
            tmp[k++] = ls[mid++];
        }
        else {
            tmp[k++] = ls[left++] ;
        }   
    }
    //左边容器元素有剩余
    if(left <= m) {
        while(left <= m) {
            tmp[k++] = ls[left++] ;
        }
    }
    else {//右边容器元素有剩余
        while(mid<=r) {
            tmp[k++] = ls[mid++] ;
        }
    }       
}

void mergePass(vector<int>&ls, vector<int>&tmp, int s, int n) {
    //合并大小为s的相邻子数组
    int i= 0;   

    while(i<=n-2*s) {
        //合并大小为s的相邻2段子数组
        merge(ls, tmp, i, i+s-1, i+2*s-1) ;
        i = i+2*s ;
    }
    //剩余的元素少于2s的话,例如s=1,n为奇数,那么最后将会剩余1个元素<2s
    if(i+s<n) {
        merge(ls, tmp, i, i+s-1, n-1) ;
    }

    else {
        for(int k=i; k<=n-1; k++) {//直接将容器ls中剩余的元素放入容器tmp中
            tmp[k] = ls[k] ;
        }
    }
}

//合并排序非递归
void mergeSort(vector<int>&ls) {   
    vector<int>tmp =ls ;//临时容器tmp
    int s= 1 ;//作为一个标记
    int len = ls.size();//容器ls的长度
    while(s<len) {
        mergePass(ls, tmp, s, len) ;
        s+=s ;
        mergePass(tmp, ls, s, len) ;
        s+=s ;
    }
}

int main()
{
    vector<int>ls ;///vector是向量类型，可以容纳许多类型的数据，因此也被称为容器
    while(1) {
        int n ;
        cin >> n ;
        if(n == -1) {
            break ;
        }
        ls.push_back(n) ;//向ls中添加元素
    }

    mergeSort(ls) ;//容器排序
    for(int i=0; i<(int)ls.size(); i++) {//输出排好序的元素
        cout << ls[i] <<"  "  ;
    }
    return 0;
}

 

4.思考拓展-逆序对求解

20200930

参考链接：https://blog.csdn.net/qq_41550842/article/details/81215935?utm_medium=distribute.pc_relevant.none-task-blog-title-1&spm=1001.2101.3001.4242

 

4.1.问题描述

给定有序表A[1:n]，修改合并排序算法，求出该有序表中的逆序对数。

 

4.2.问题分析

 

用归并排序顺便完成统计逆序对数。

因为合并操作是从小到大进行的，当右边的a[q]复制到T中时，左边还没来得及复制到T中的那些数就是左边所有比a[q]大的数。

此时在累加器中加上左边的元素个数m-p即可（左边剩余元素在区间[p,m)中，因此元素个数为m-p.）

 

如下图，为分治算法中的“治”，即合并数组。第二步中，当进行从小到大的合并操作时，右边的元素复制到新的数组中时，左边未来得及放入数组中的元素8比右边数组中的元素5,7都大，

 

下面我们来看一个例子：

设有数列{6，202，100，301，38，8，1}

初始状态：6,202,100,301,38,8,1

第一次归并后：{6,202},{100,301},{8,38},{1}，比较次数：3；逆序对：0

第二次归并后：{6,100,202,301}，{1,8,38}，比较次数：4；逆序对：4

第三次归并后：{1,6,8,38,100,202,301},比较次数：4；逆序对：10

总的比较次数为：3+4+4=11；

逆序数为:0+4+10=14；

 

下面是我结合代码和上述例子画的图，如果对于代码了解了，可以略过此图：

 

 

4.3.代码实现

代码连接：https://blog.csdn.net/qq_41550842/article/details/81215935?utm_medium=distribute.pc_relevant.none-task-blog-title-1&spm=1001.2101.3001.4242

// 2_7_test1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include<stdio.h>
#include <iostream.h>
#define N 100005
int a[N],b[N];//b为辅助数组
int cnt;

void merge_sort(int l,int r)
{
    if(r-l>0)//如果区间元素个数大于1，则继续分割
    {
        int mid=(l+r)/2;
        int i=l;//辅助数组b的下标
        int p=l,q=mid+1;//p,q分别为合并比较时左右两边的下标
        merge_sort(l,mid);
        merge_sort(mid+1,r);
        //printf("%d-%d  %d-%d\n",p,mid ,q ,r);
        while(p<=mid || q<=r)//左右两边只要有一边有剩余
        {
            if(q>r || (p<=mid && a[p]<=a[q]))//左边元素有剩余，且元素小于右边的，则直接复制到辅助数组中去
                b[i++] = a[p++];
            else{//如果左边元素大于右边，则存在逆序对
                b[i++] = a[q++];
                cnt += mid-p+1;//逆序对的个数累加
            }
        }

        for(i=1; i<=r; i++)//将辅助数组b中排好的逆序对复制到a中
            a[i] = b[i];
    }

}



int main(int argc, char* argv[])
{
    int n,i;
    cout<<"一共要输入多少个元素呢？"<<endl;
    while(cin >> n)
    {
        cout<<"请输入数组中的元素："<<endl;
        for(i = 1 ; i <= n; i ++)
            cin >> a[i];
        cnt = 0;//初始化逆序对数为0对
        merge_sort(1 , n);
        for(i = 1; i <= n; i++)
            cout << a[i] << " ";
        cout << endl;
        cout << "逆序对有：" << cnt <<endl;
    }
    return 0;
}