数据结构-排序2 归并排序

这是一种自上而下先将一组数组拆分为两组，不断的往下拆分，当每组只剩下一个的时候递归结束

然后在开辟一个新的数组 aux，将这组数据进行保存。然后两组数组的元素进行比较，再重新赋予给a数组

1.这是一种自上而下的递归算法。

#include <iostream>
#include <algorithm>
using namespace std;
void mergeguibing(int a[],int l,int mid ,int r)
{
    int i,j,k;
    int aux[r-l+1];// 9-0+1
    for(i=l;i<=r;i++){
        aux[i-l]=a[i];//数组要从0开始，其实这就是花费空间换时间的方法
    }
    i=l;
    j=mid+1;
    for(k=l;k<=r;k++)
    {
        if(i>mid)//当前两组中的一组已经添加到a中完成了，剩下的另一组都是有序的，
                //直接放到a中就行
        {
            a[k]=aux[j-l];//数组从0开始
            j++;
        }else if(j>r){
            a[k]=aux[i-l];
            i++;
        }
        else if(aux[i-l]<aux[j-l])
        {
            a[k]=aux[i-l];
            i++;
        }else{
            a[k]=aux[j-l];
            j++;
        }
    }
}

void guibingpaixu(int a[],int l,int r)
{
    int mid,i,j,k;
    if(l>=r) return ;
    mid=(l+r)/2;//如果严谨的话，l+r可能会越界，注意范围
    //把一组分成两组
    guibingpaixu(a,l,mid);
    guibingpaixu(a,mid+1,r);
    //每两组和成为一组
    mergeguibing(a,l,mid,r);
}
int main(){
    int a[10]={1,5,2,6,7,8,9,4,0,3};
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
    
    guibingpaixu(a,0,10-1);
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<" ";
    }
    return 0;
}

2.自底而上的递推算法，迭代算法

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

void mergeguibing(int a[],int l,int mid ,int r)
{
    int i,j,k;
    int aux[r-l+1];// 9-0+1
    for(i=l;i<=r;i++){
        aux[i-l]=a[i];//数组要从0开始，其实这就是花费空间换时间的方法
    }
    i=l;
    j=mid+1;
    for(k=l;k<=r;k++)
    {
        if(i>mid)//当前两组中的一组已经添加到a中完成了，剩下的另一组都是有序的，
                //直接放到a中就行
        {
            a[k]=aux[j-l];//数组从0开始
            j++;
        }else if(j>r){
            a[k]=aux[i-l];
            i++;
        }
        else if(aux[i-l]<aux[j-l])
        {
            a[k]=aux[i-l];
            i++;
        }else{
            a[k]=aux[j-l];
            j++;
        }
    }
}

/*void guibingpaixu(int a[],int l,int r)
{
    int mid,i,j,k;
    if(l>=r) return ;
    mid=(l+r)/2;//如果严谨的话，l+r可能会越界，注意范围
    //把一组分成两组
    guibingpaixu(a,l,mid);
    guibingpaixu(a,mid+1,r);
    //每两组和成为一组
    mergeguibing(a,l,mid,r);
}*/
void guibingpaixuBU(int a[],int n)//这个n是数组的元素个数
{
    int sz,i;
    for(int sz=1;sz<=n;sz+=sz)//sz的大小实际上是自底而上的每两组数组比较的每组数组的个数，第一次每个数组是1个，第二次2个，第三次4个
    {   //i+sz不能越界
        for(i=0;i+sz<n;i+=sz+sz)//i的跨界是一次要跨过两组的的个数，实现另外两组的比较
        {     //这里的i+sz-1，是因为数组是从0开始的。比如前半部分有两个元素，那么从i开始包括i，i+1，而i+2则属于后半部分的数组了，i+sz+sz-1同理
            mergeguibing(a,i,i+sz-1,min(i+sz+sz-1,n-1));//取最小值也是为了不越界
        }
    }
}
int main(){
    int a[10]={1,5,2,6,7,8,9,4,0,3};
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
    //自上而下的递归方法
    //guibingpaixu(a,0,10-1);
    //
    guibingpaixuBU(a,10);
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<" ";
    }
    return 0;
}

归并排序的应用，求逆序数对

#include <iostream>
#include <algorithm>
using namespace std;
int sum=0;
void youhuacharu(int a[],int n){
    int i,j,e;
    for(i=1;i<n;i++)
    {
        e=a[i];
        for(j=i;j>0;j--)
        {
            if(a[j-1]>e)
            {
                a[j]=a[j-1];
            }else
            {
                break;//因为之前的已经排好序了,如果有比e小的，那么e就在a[j]的后面
            }
        }
        a[j]=e;//然后将e赋值给a[j]
    }
     for(i=0;i<n;i++)
    {
        cout<<a[i]<<" ";
    }
}

void mergeguibing(int a[],int l,int mid ,int r)
{
    int i,j,k;
    int aux[r-l+1];// 9-0+1
    for(i=l;i<=r;i++){
        aux[i-l]=a[i];//数组要从0开始，其实这就是花费空间换时间的方法
    }
    i=l;
    j=mid+1;
    for(k=l;k<=r;k++)
    {
        if(i>mid)//当前两组中的一组已经添加到a中完成了，剩下的另一组都是有序的，
                //直接放到a中就行
        {
            a[k]=aux[j-l];//数组从0开始
            j++;
        }else if(j>r){
            a[k]=aux[i-l];
            i++;
        }
        else if(aux[i-l]<=aux[j-l])
        {
            a[k]=aux[i-l];
            i++;
        }else{
            sum+=mid+1-i;//在已经排好序的递归数组中，从小到大排序的，i之后到mid的都比j要大
            for(int x=0;x<mid-i+1;x++)
            {
                cout<<aux[i-l+x]<<"->"<<aux[j-l]<<" ";
            }
            cout<<endl;
            a[k]=aux[j-l];
            j++;
        }
    }
}

void guibingpaixu(int a[],int l,int r)
{
    int mid,i,j,k;
    if(l>=r) return ;
    mid=(l+r)/2;//如果严谨的话，l+r可能会越界，注意范围
    //把一组分成两组
    guibingpaixu(a,l,mid);
    guibingpaixu(a,mid+1,r);
    //每两组和成为一组
    mergeguibing(a,l,mid,r);
}
void guibingpaixuBU(int a[],int n)
{
    int sz,i;
    for(int sz=1;sz<=n;sz+=sz)
    {   //i+sz不能越界
        for(i=0;i+sz<n;i+=sz+sz)
        {
            mergeguibing(a,i,i+sz-1,min(i+sz+sz-1,n-1));
        }
    }
}
int main(){
    int a[]={10,9,8,7,6,5,4,3,2,1,0};
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
    //自上而下的递归方法
    guibingpaixu(a,0,10-1);
    //
    //guibingpaixuBU(a,10);
    for(int i=0;i<10;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl<<sum<<endl;
    return 0;
}