The Divide and Conquer Approach

The divide and conquer approach - 归并排序

    归并排序所应用的理论思想叫做分治法.
    分治法的思想是: 将问题分解为若干个规模较小,并且类似于原问题的子问题,
    然后递归(recursive) 求解这些子问题, 最后再合并这些子问题的解以求得
    原问题的解.
        即, 分解 -> 解决 -> 合并.

    The divide and conquer approach 
        分解: 将待排序的含有 n 个元素的的序列分解成两个具有 n/2 的两个子序列.
        解决: 使用归并排序递归地排序两个子序列.
        合并: 合并两个已排序的子序列得出结果.

    归并排序算法的 '时间复杂度' 是 nlogn

import time, random

def sortDivide(alist):     # 分解 divide
    if len(alist) <= 1:
        return alist
    l1 = sortDivide(alist[:alist.__len__()//2])
    l2 = sortDivide(alist[alist.__len__()//2:])
    return sortMerge(l1,l2)

def sortMerge(l1, l2):     # 解决 & 合并  sort & merge
    listS = []
    print("Left - ", l1)
    print("Right - ", l2)
    i,j = 0,0
    while i < l1.__len__() and j < l2.__len__():
        if l1[i] <= l2[j]:
            listS.append(l1[i])
            i += 1
            print("-i", i)
        else:
            listS.append(l2[j])
            j += 1
            print("-j", j)
        print(listS)
    else:
        if i == l1.__len__():
            listS.extend(l2[j:])
        else:
            listS.extend(l1[i:])
        print(listS)
    print("Product -",listS)
    return listS

def randomList(n,r):
    F = 0
    rlist = []
    while F < n:
        F += 1
        rlist.append(random.randrange(0,r))
    return rlist

if __name__ == "__main__":
    alist = randomList(9,100)
    print("List-O",alist)
    startT =time.time()
    print("List-S", sortDivide(alist))
    endT = time.time()
    print("Time elapsed :", endT - startT)

output,
    List-O [88, 79, 52, 78, 0, 43, 21, 55, 62]
    Left -  [88]
    Right -  [79]
    -j 1
    [79]
    [79, 88]
    Product - [79, 88]
    Left -  [52]
    Right -  [78]
    -i 1
    [52]
    [52, 78]
    Product - [52, 78]
    Left -  [79, 88]
    Right -  [52, 78]
    -j 1
    [52]
    -j 2
    [52, 78]
    [52, 78, 79, 88]
    Product - [52, 78, 79, 88]
    Left -  [0]
    Right -  [43]
    -i 1
    [0]
    [0, 43]
    Product - [0, 43]
    Left -  [55]
    Right -  [62]
    -i 1
    [55]
    [55, 62]
    Product - [55, 62]
    Left -  [21]
    Right -  [55, 62]
    -i 1
    [21]
    [21, 55, 62]
    Product - [21, 55, 62]
    Left -  [0, 43]
    Right -  [21, 55, 62]
    -i 1
    [0]
    -j 1
    [0, 21]
    -i 2
    [0, 21, 43]
    [0, 21, 43, 55, 62]
    Product - [0, 21, 43, 55, 62]
    Left -  [52, 78, 79, 88]
    Right -  [0, 21, 43, 55, 62]
    -j 1
    [0]
    -j 2
    [0, 21]
    -j 3
    [0, 21, 43]
    -i 1
    [0, 21, 43, 52]
    -j 4
    [0, 21, 43, 52, 55]
    -j 5
    [0, 21, 43, 52, 55, 62]
    [0, 21, 43, 52, 55, 62, 78, 79, 88]
    Product - [0, 21, 43, 52, 55, 62, 78, 79, 88]
    List-S [0, 21, 43, 52, 55, 62, 78, 79, 88]
    Time elapsed : 0.0010027885437011719