算法設計：合並排序與自底向上合並排序

在我們之前的算法設計課程中，我們學習了合並排序與自底向上合並排序算法，今天我們就來分析一下這個算法

合並算法

無論是合並排序還是自底向上合並排序，他的實現都基於一個重要的算法：合並算法（merge算法）。Merge算法實現的功能是將兩個數組合並成為一個數組，我們可以定義一個結果數組b，再分別定義兩個索引p1、p2，分別指向兩個數組的頭，將p1、p2指向的兩個數進行比較，並將較小的那一個放入數組b

Merge算法的偽碼如下：

merge(p, q, r, a[]):

1. s←p; t←q+1; k←p
2. while s≤q and t≤r
3.     if a[s] ≤ a[t] then
4.         b[k] ← a[s]
5.           s ←s+1
6. 6.           else
7.           b[k]←a[t]
8.           t←t+1
9. 9.           end if
10.     k←k+1
11. 11.   end while
12. if s=q+1 then b[k…r]←a[t…r]
13. else b[k…r]←a[s…q]
14. 14.   end if
15. a[p…r]←b[p…r]

 

自底向上合並排序算法

自底向上合並算法顧名思義，就是從最底部開始，將數組元素兩兩合並，再將合並后的數組兩兩合並，直到重新合並成一個完整的數組。對於數組a = {9,4,5,2,1,7,4,6}的合並過程可以用如下圖來表示：

自底向上合並排序算法偽碼如下：

BottomSort(a[]):

1. t←1
2. while t<n
3.     s←t; t←2s; i←0
4.     while i+t≤n
5.           merge(i+1, i+s, i+t, a)
6.           i←i+t
7. 7.           end while
8.     if i+s<n then merge(i+1, i+s, n)
9. 9.       end while

合並排序算法

合並排序算法與自底向上合並排序十分相似（廢話！），只不過與自底向上合並排序不同的是，合並排序是一個自頂向下的過程。我們可以將一整個數組拆分成兩個數組，將其中的一個數組再進行拆分，直到拆分成兩個單個元素，再將他們合並…重復此過程直到整個數組都重新合並完畢。

對於數組a[]={9,4,5,2,1,7,4,6}的合並排序可以用如下圖示表示：

其中頂端數組表示其獲得的輸入，底端數組表示其合並后的輸出

合並排序算法偽碼如下：

mergesort(low, high, a[]):

1. if low<high then
2.     mid←(low + high)/2
3.     mergesort(low, mid, a)
4.     mergesort(mid+1, high, a)
5.     merge(low, mid, high, a)
6. 6.       end if

兩個算法的完整代碼

自底向上合並排序（java）：

//自底向上合並排序
public class BottomUpSort {
    public static void main(String args[])
    {
        int a[] = {9,4,5,2,1,7,4,6};
        bottomUpSort(a);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println();
    }
    
    public static void bottomUpSort(int a[])
    {
        int i, s, t = 1;
        while(t < a.length-1)
        {
            s = t;
            t = 2*s;
            i = 0;
            for(;i+t < a.length;i+=t)
                merge(i, i+s-1, i+t-1, a);    //自底向上進行排序
            if(i+s-1 < a.length-1)    //判斷是否有落單元素
                merge(i, i+s-1, a.length-1, a);
            
        }
    }
    
    public static void merge(int low, int mid, int high, int a[])
    {
        int b[] = new int[a.length];    //    建立轉存數組
        int f = low, s = mid+1, p = low;
        //f為第一個數組索引，s為第二個數組索引，p為b數組索引
        while(f<=mid && s<=high)
        {
            //在兩個數組元素中值小的一方放入b數組
            if(a[f] <= a[s])
            {
                b[p] = a[f];
                f++;
            }
            else
            {
                b[p] = a[s];
                s++;
            }
            p++;
        }
        
        if(f == mid+1)    //若第一個數組中的元素全部存儲進去了，那么將第二個數組中的剩余元素全部放入b數組
            for(;s <= high && p<=high;p++,s++)
                b[p] = a[s];
        else //否則將第一個數組中的元素全部放入b數組
            for(;f<=mid && p<=high;p++,f++)    
                b[p] = a[f];
        
        for(int i=low;i<=high;i++)
            a[i] = b[i];
    }
}

自底向上合並排序（c）：

#include<stdio.h>

//數組合並函數
void merge(int low, int mid, int high, int a[])
{
    int b[50];    //定義轉存數組
    int f = low, s = mid + 1, p = low;
    //f表示第一個數組的索引，s表示第二個數組的索引，p表示b數組的索引

    while (f <= mid && s <= high)
    {
        //將兩個數組中值小的一方存入數組b
        if (a[f] <= a[s])
        {
            b[p] = a[f];
            f++;
        }
        else
        {
            b[p] = a[s];
            s++;
        }
        p++;
    }
    if (f == mid + 1)    //若第一個數組都存進了數組b，那么將第二個數組中的剩下元素全部存入
        for (; s <= high; p++, s++)
            b[p] = a[s];
    else    //否則將第一個數組中的剩下元素全部存入
        for (; f <= mid; p++, f++)
            b[p] = a[f];

    for (int i = low; i <= high; i++)
        a[i] = b[i];    //將合並后的數組轉存回a
}

void BottomUpSort(int low, int high, int a[])
{
    int t = 1, s, i;
    int length = high + 1;
    while (t < length-1)
    {
        s = t;
        t = 2 * s;
        i = 0;
        for (; i + t <= length - 1; i+=t)    //自底向上進行合並
            merge(i, i + s - 1, i + t - 1, a);
        if (i + s-1 < length - 1)    //判斷是否有落單元素
            merge(i, i + s - 1, length - 1, a);
    }
}

int main()
{
    int a[] = { 9,4,5,2,1,7,4,6 };
    int length = sizeof(a) / sizeof(a[0]);
    for (int i = 0; i < length; i++)
        printf("%d ", a[i]);
    printf("\n");
    BottomUpSort(0, length - 1, a);
    for (int i = 0; i < length; i++)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}

合並排序（java）:

//合並排序算法
public class MergeSort {
    public static void main(String args[])
    {
        int a[] = {9,4,5,2,1,7,4,6};
        mergeSort(0, a.length-1, a);
        for(int i=0;i<a.length;i++)
            System.out.print(a[i] + " ");
        System.out.println();
    }
    
    //合並排序
    public static void mergeSort(int low, int high, int a[])
    {
        if(low < high)
        {
            int mid = (low + high)/2;
            mergeSort(low, mid, a);
            mergeSort(mid+1, high, a);
            merge(low, mid, high, a);
        }
    }
    
    //合並兩個數組
    public static void merge(int low, int mid, int high, int a[])
    {
        int b[] = new int[a.length];    //    建立轉存數組
        int f = low, s = mid+1, p = low;
        //f為第一個數組索引，s為第二個數組索引，p為b數組索引
        while(f<=mid && s<=high)
        {
            //在兩個數組元素中值小的一方放入b數組
            if(a[f] <= a[s])
            {
                b[p] = a[f];
                f++;
            }
            else
            {
                b[p] = a[s];
                s++;
            }
            p++;
        }
        
        if(f == mid+1)    //若第一個數組中的元素全部存儲進去了，那么將第二個數組中的剩余元素全部放入b數組
            for(;s <= high && p<=high;p++,s++)
                b[p] = a[s];
        else //否則將第一個數組中的元素全部放入b數組
            for(;f<=mid && p<=high;p++,f++)    
                b[p] = a[f];
        
        for(int i=low;i<=high;i++)
            a[i] = b[i];
    }
}

合並排序（c）:

#include<stdio.h>

//數組合並函數
void merge(int low, int mid, int high, int a[])
{
    int b[50];    //定義轉存數組
    int f = low, s = mid + 1, p = low;
    //f表示第一個數組的索引，s表示第二個數組的索引，p表示b數組的索引

    while (f <= mid && s <= high)
    {
        //將兩個數組中值小的一方存入數組b
        if (a[f] <= a[s])
        {
            b[p] = a[f];
            f++;
        }
        else
        {
            b[p] = a[s];
            s++;
        }
        p++;
    }
    if (f == mid+1)    //若第一個數組都存進了數組b，那么將第二個數組中的剩下元素全部存入
        for (; s <= high; p++, s++)
            b[p] = a[s];
    else    //否則將第一個數組中的剩下元素全部存入
        for (; f <= mid; p++, f++)
            b[p] = a[f];

    for (int i = low; i <= high; i++)
        a[i] = b[i];    //將合並后的數組轉存回a
}

//合並排序函數
void MergeSort(int low, int high, int a[])
{
    if (low < high)
    {
        int mid = (low + high) / 2;
        MergeSort(low, mid, a);    
        MergeSort(mid + 1, high, a);    //從上到下合並數組
        merge(low, mid, high, a);
    }
}

int main()
{
    int a[] = { 9,4,5,2,1,7,4,6 };
    int length = sizeof(a) / sizeof(a[0]);
    for (int i = 0; i < length; i++)
        printf("%d ", a[i]);
    printf("\n");
    MergeSort(0, length - 1, a);
    for (int i = 0; i < length; i++)
        printf("%d ", a[i]);
    printf("\n");
    return 0;
}