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