数据结构和算法基础 Python实现

基于归并算法（或分治策略）的算法应用

---

目录：

基于归并算法（或分治策略）的算法应用

1. 归并法求大整数乘法: Karastuba Multiplication Algorithm

 2. 归并排序（基于二分法）：Merge sort 

3. 快速排序：Quick sort

---

1. 归并法求大整数乘法: Karastuba Multiplication Algorithm

def kara_multi(num1,num2):

    if num1<=10 or num2<=10:
        return num1 * num2

    n1 = len(str(num1))
    n2 = len(str(num2))
    nhalf = int(max(n1,n2)/2)
    #get the a,b,c,d of the numbers
    a = int(str(num1)[0:n1-nhalf])
    b = int(str(num1)[n1-nhalf:])
    c = int(str(num2)[0:n2-nhalf])
    d = int(str(num2)[n2-nhalf:])

    #calculate three parts in karastuba algorithm
    z0 = kara_multi(a, c)
    z1 = kara_multi(b, d)
    z2 = kara_multi((a+b),(c+d)) - z0 - z1

    return z0 * 10**(2*nhalf) + z2 * 10**nhalf + z1

if __name__ == '__main__':

    num1 = 2718281828459045235360287471352662497757247093699959574966967627
    num2 = 3141592653589793238462643383279502884197169399375105820974944592

    out = kara_multi(num1,num2)
    print(out)

    # Getting result：    
8539734222673567065463550869546574495034888535765114961879601127067743044893204848617875072216249073013374895871952806582723184

---

2. 归并排序：Merge sort

import numpy as np

def Mergesort(arr):
    n = arr.size
    nhalf = int(n/2)

    if n < 4:
        return merge(arr[:nhalf], arr[nhalf:])

    lefthalf = Mergesort(arr[:nhalf])
    righthalf = Mergesort(arr[nhalf:])

    return merge(lefthalf,righthalf)


def merge(arr1,arr2):
    i = 0
    j = 0
    n = arr1.size + arr2.size
    temp = np.zeros(n).astype(int)
    for k in range(n):
        if arr1[i]<=arr2[j]:
            temp[k] = arr1[i]
            i += 1
        else:
            temp[k] = arr2[j]
            j += 1
        if i == arr1.size:
            temp[k+1:] = arr2[j:]
            return temp
        elif j == arr2.size:
            #print(k,temp.shape,arr1.shape,temp,arr1)
            temp[k+1:] = arr1[i:]
            return temp


if __name__ == '__main__':
    import time

    time_start = time.time()
    a = [2,5,1,1,45,3,46,6,2,64,45,3,6,3,2,6,44]
    b = np.array(a)
    out = Mergesort(b)
    print(out)

    time_end = time.time()
    print('totally cost: %.5f ms' %((time_end - time_start)*(10**3)))   # test using time 18.92185 ms

---

3. 快速排序：Quick sort

import numpy as np

def quicksort(array, p, r):

    if p < r:
        q = partition(array, p, r)
        quicksort(array, p, q-1)
        quicksort(array, q + 1, r)

    return array


def partition(array, p, r):
    i = p
    j = r
    selection = array[p]
    while 1:
        while i<j and array[i] <= selection:
            i += 1
        while i<j and array[j] >= selection:
            j -= 1
        if i>=j:
            break
        temp = array[j]
        array[j] = array[i]
        array[i] = temp

    if array[p] > array[j]:
        array[p] = array[j]
        array[j] = selection

        return j
    else:
        array[p] = array[j-1]
        array[j-1] = selection
        return j-1


if __name__ == '__main__':
    import time

    time_start = time.time()

    a = [2,5,1,1,45,3,46,6,2,64,45,3,6,3,2,6,44]
    b = np.array(a)
    r = b.size-1
    out = quicksort(b, 0, r)
    print(out)

    time_end = time.time()
    print('totally cost: %.5f ms' %((time_end - time_start)*(10**3)))  # test using time 0.99683 ms