二路歸並排序(非遞歸實現)

歸並排序是一種借助”歸並“進行排序的方法。

歸並的含義是將兩個或兩個以上的有序序列歸並為一個有序序列的過程。歸並排序的主要思想是：將若干有序序列逐步歸並，最終歸並為一個有序序列。

其中最常見的是二路歸並排序。

二路歸並排序是一種穩定的排序方法，其基本思想是：將若干個有序序列兩兩歸並，直到形成一個有序序列為止。

方法如下：將一個長度為n的無序序列看作是n個長度為1的有序序列的集合。然后兩兩歸並，直到整個序列有序。

在歸並的過程中，可能會破壞原序列的有序性，所以需要一個新的數組在存儲歸並后的結果。

一次歸並的算法是從開始同時遍歷兩個序列，將較小的值放入結果序列中，直到遍歷結束，成為一個有序序列。

代碼如下：

void Merge(int r[],int r1[],int s,int m,int t)
{
    int i=s,j=m+1,k=s;
    while(i<=m&&j<=t)
    {
        if(r[i]<=r[j])
        {
            r1[k]=r[i];
            i++;
            k++;
        }
        else 
        {
            r1[k]=r[j];
            j++;
            k++;
        }
    }
    if(i<=m)
    {
        while(i<=m) 
        {
            r1[k]=r[i];
            i++;
            k++;
        }
    }
    else
    {
        while(j<=t)
        {
            r1[k]=r[j];
            j++;
            k++;
        }
    }
}

然后，一趟遍歷只需要不斷調用一次歸並的算法就可以實現了。

void MergePass(int r[] ,int r1[] , int n, int h)
{
    int i=1;
    while(i<=n-2*h+1)
    {
        Merge(r,r1,i,i+h-1,i+2*h-1);
        i+=2*h;
    }
    if(i<n-h+1) Merge(r,r1,i,i+h-1,n);
    else for(int k=i; k<=n; k++)
    {
        r1[k]=r[k];
    }
}

開始時，有序序列長度為1，結束時，有序序列長度為n，所以，可以用有序序列的長度來控制排序的結束時刻。同時，排序次數為奇數時，還需要將輔助數組中的值放回原數組。

下面給出歸並排序非遞歸算法：

void MergeSort(int r[],int r1[], int n)
{
    int h=1;
    while(h<n)
    {
        MergePass(r,r1,n,h);
        h*=2;
        MergePass(r1,r,n,h);
        h*=2;
    }
}

時間復雜度與空間復雜度分析

對於二路歸並排序來說，它的時間復雜度比較直觀，運行一趟需要掃描數據一次，一趟的時間復雜度為O(n)。整個歸並排序需要運行[log₂n]趟。所以，總體的時間復雜度為O(nlogn)。

對於空間復雜度，在排序時，算法使用了一個與待排序序列等長的輔助空間來存放結果，所以其空間復雜度為O(n)。

所以說，二路歸並排序是一種穩定的排序方法，它的最好、最壞、平均的時間復雜度相等。

 

 

下面給出完整代碼：

#include<iostream>
using namespace std;

void Merge(int r[],int r1[],int s,int m,int t)
{
    int i=s,j=m+1,k=s;
    while(i<=m&&j<=t)
    {
        if(r[i]<=r[j])
        {
            r1[k]=r[i];
            i++;
            k++;
        }
        else 
        {
            r1[k]=r[j];
            j++;
            k++;
        }
    }
    if(i<=m)
    {
        while(i<=m) 
        {
            r1[k]=r[i];
            i++;
            k++;
        }
    }
    else
    {
        while(j<=t)
        {
            r1[k]=r[j];
            j++;
            k++;
        }
    }
}

void MergePass(int r[] ,int r1[] , int n, int h)
{
    int i=1;
    while(i<=n-2*h+1)
    {
        Merge(r,r1,i,i+h-1,i+2*h-1);
        i+=2*h;
    }
    if(i<n-h+1) Merge(r,r1,i,i+h-1,n);
    else for(int k=i; k<=n; k++)
    {
        r1[k]=r[k];
    }
}

void MergeSort(int r[],int r1[], int n)
{
    int h=1;
    while(h<n)
    {
        MergePass(r,r1,n,h);
        h*=2;
        MergePass(r1,r,n,h);
        h*=2;
    }
}

int main()
{
    int a[10000];
    int a1[10000];
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    MergeSort(a,a1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
    cout<<endl;
    return 0;
}