列表的歸併排序

歸併排序

1. 算法原理和Python代碼

歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分爲若干個子序列，每個子序列是有序的。然後再把有序子序列合併爲整體有序序列。
首先用Python實現合併兩個有序列表的操作。這個非常簡單，只要從比較二個列表的第一個數，誰小就先取誰，取了後就將相應的下標右移一位。然後再進行比較，如果有列表訪問結束，那直接將另一個列表的數據依次取出即可。

#coding:utf-8
#合併有序列表
def mergeList(a, b):            
    c = []
    i = 0
    j = 0
    while i < len(a) and j < len(b):
        print "1:",i,j
        if a[i] < b[j]:
            c.append(a[i])
            i += 1
        else:
            c.append(b[j])
            j += 1
    while i < len(a):
        c.append(a[i])
        i += 1
    while j < len(b):
        c,append(b[j])
        j += 1      
    return c
a = [1,3,5,6,7,8]
b = [2,4,6]
print mergeList(a, b)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

注意：合併有序列表的時間複雜度爲O（n）。

解決了上面的合併有序列表問題，再來看歸併排序，其的基本思路就是將列表分成二組A，B，如果這二組組內的數據都是有序的，那麼就可以很方便的將這二組數據進行排序。如何讓這二組組內數據有序了？
可以將A，B組各自再分成二組。依次類推，當分出來的小組只有一個數據時，可以認爲這個小組組內已經達到了有序，然後再合併相鄰的二個小組就可以了。這樣通過先遞歸的分解列表，再合併列表就完成了歸併排序。

#拆分列表
def mergeSort(p, first, last):
    new = []
    if first < last:
        mid = (first + last)/2
        mergeSort(p, first, mid)
        mergeSort(p, mid + 1, last)
        a = p[first:mid + 1] #列表的索引性質:列表a中不包含p[mid + 1]元素
        b = p[mid + 1:last + 1]
        print "a:", a
        print "b:", b
        new = mergeList(a, b)
        print "new:",new
        start = first
        for i in new:  #將合併好的列表複製到p列表相應的位置中
            p[start] = i
            start += 1
        print "p:",p
    return p

p = [2,3,1,7,5,9,10,4,6,8]
first = 0
last = len(p) - 1
print mergeSort(p, first, last)

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24

2. 時間複雜度和空間複雜度分析

2.1 時間複雜度

平均複雜度和最壞複雜度都是O(nlogn)

def mergeSort(p, first, last):        #T(n)
    if first < last:
        mid = (first + last)/2
        mergeSort(p, first, mid)      #T(n/2)
        mergeSort(p, mid + 1, last)   #T(n/2)
        new = mergeList(a, b)         #O(n)
        ...
    return p

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

所以當n=1時，T(n)=O(1)；當n>1時，T(n)=2T(n/2)+O(n)
求解這個遞歸方程，
（根據數學知識，遇到類似的公式，T(n)=aT(n/b)+O(n)，就應該令n=b^k（b的k次方），才能轉化公式爲可求解形式。)

網上找到的方法，根據公式的格式，採用假設的方法，網頁鏈接

2.2 空間複雜度

佔用大小爲n的空間，存放代碼中new列表，然後將new 列表再複製爲p列表。

3 算法改進

自然合併排序原理：用1次對列表中的線性掃描找到所有的排好序的子列表，然後再將這些子列表兩兩合併。這種情況的合併次數較少，時間爲O(n)。

轉載:https://blog.csdn.net/aq_cainiao_aq/article/details/75571000