歸併排序（MergeSort）

歸併排序（英語：Merge sort，或mergesort），是建立在歸併操作上的一種有效的排序演算法，效率為 O(n\log n)（大O符號）。1945年由約翰·馮·諾伊曼首次提出。該演算法是採用分治法（Divide and Conquer）的一個非常典型的應用，且各層分治遞迴可以同時進行

遞迴法（Top-down）

1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合併後的序列
2. 設定兩個指標，最初位置分別為兩個已經排序序列的起始位置
3. 比較兩個指標所指向的元素，選擇相對小的元素放入到合併空間，並移動指標到下一位置
4. 重複步驟3直到某一指標到達序列尾
5. 將另一序列剩下的所有元素直接複製到合併序列尾

Python實現

def mergeSort(nums):
    if len(nums) < 2:
        return nums
    mid=len(nums)//2
    left=mergeSort(nums[:mid])
    right=mergeSort(nums[mid:])
    return megre(left,right)

def megre(left,right):
    result=[]
    i=j=0
    while j<len(left) and i <len(right):
        if left[j] < right[i]:
            result.append(left[j])
            j+=1
        else:
            result.append(right[i])
            i+=1
    if j==len(left):
        for temp in right[i:]:
            result.append(temp)
    else:
        for temp in left[j:]:
            result.append(temp)
    return result

if __name__ == "__main__":
    nums = [1, 4, 2, 3.6, -1, 0, 25, -34, 8, 9, 1, 0]
    print("original:", nums)
    print("Sorted:", mergeSort(nums))　　

輸出內容：

C:\Python27\python.exe D:/code-program/lianxi-test/二叉搜尋樹.py
('original:', [1, 4, 2, 3.6, -1, 0, 25, -34, 8, 9, 1, 0])
('Sorted:', [-34, -1, 0, 0, 1, 1, 2, 3.6, 4, 8, 9, 25])

Process finished with exit code 0

c語言版本　

void merge_sort_recursive(int arr[], int reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}

void merge_sort(int arr[], const int len) {
    int reg[len];
    merge_sort_recursive(arr, reg, 0, len - 1);
}