coursera Algorithm 课程 divide and conquer 第一周笔记

1.interger algorithm

普通乘法需要执行 constant * n^2 次的运算，这并不令人满意。
一个好的程序设计者最重要的事情是：
从来不要满足，尤其是对这些看似简单的问题。

2.Karatsuba mutiplication（含代码）

$x*y =$

1. Recursively compute ac
2. Recursively compute bd
3. Recursively compute (a+b)(c+d)=ac+bd+ad+bc
Gauss’Trick:(3)–(1)–(2)= ad+bc

only need 3 recursions rather than 4!
代码实现：（python）
#给定两个乘数，用Karatsuba mutiplication做算法

#x,y

def multiply(x, y, n):
    if (n == 1):
        return x * y
    a = x // 10**(n // 2)
    b = x % (10**(n // 2))
    c = y // (10**(n // 2))
    d = y % (10**(n // 2))
    ac = multiply(a, c, n // 2)
    bd = multiply(b, d, n // 2)
    mid = multiply(a + b, c + d, n // 2) - ac - bd
    sum = 10**n * ac + 10**(n // 2) * mid + bd
    return sum

3. merge sort algorithm （含代码）

排列算法有：
selection, insertion, bubble sort

merge sort (合并排列）

伪代码（合并过程）：

计算时间分析：
对于合并过程，计算次数是 4n+2 <= 6n

最终所有过程的次数不超过 6nlogn+6n
即是O(nlogn)
原因解释：

对于每一层级j(j=0,1,…n)
这一层的操作总次数是 $2^j *6*(n/2^j) = 6n$次
共有 $log_2n+1$个层级
所以总操作不超过 $6nlogn+6n$
代码实现(python)

#给定一个数组,进行排序(合并排序)
a = [1, 4, 2, 6, 0, 8, 5, 3, 9, 7]


def merge_sort(a):
    a = a.copy()
    length = len(a)
    if (length <= 1):
        return a
    else:
        a1 = merge_sort(a[0:length // 2])
        a2 = merge_sort(a[length // 2:])
        #对两个数组进行合并
        m = 0
        n = 0
        for i in range(len(a)):
            if (a1[m] < a2[n]):
                a[i] = a1[m]
                m += 1
            else:
                a[i] = a2[n]
                n += 1
            ##结束标志
            if (m >= len(a1)):
                a[i + 1:] = a2[n:]
                break
            elif (n >= len(a2)):
                a[i + 1:] = a1[m:]
                break
    return a


print(merge_sort(a))