算法设计与分析基础（python实现）-- 2

分治法

分治法的思想：
1.将问题的实例划分为同一个问题的几个较小实例，最好具有相同的规模
2.对这些较小的实例进行求解（一般使用递归方法，但在问题规模足够小时，也会使用一些其他的方法）
3.如果有必要的话，合并这些较小问题的解，以得到原始问题的解。

算法运行时间：

主定理：
合并排序
算法：

import math

def merge(b, c, a):
    blength = len(b)
    clength = len(c)
    i = 0
    j = 0
    k = 0
    while i<blength and j<clength:
        if b[i] <= c[j]:
            a[k] = b[i]
            i += 1
        else:
            a[k] = c[j]
            j += 1
        k += 1
    if i < blength:
        a[k:blength+clength] = b[i:blength]
    else:
        a[k:blength+clength] = c[j:clength]

def mergesort(a_list):
    length = len(a_list)
    if length > 1:
        b_list = a_list[0:math.floor(length/2)]
        c_list = a_list[math.floor(length/2):length]
        mergesort(b_list)
        mergesort(c_list)
        merge(b_list, c_list, a_list)
    return a_list

if __name__ == '__main__':
    a_list = [8,3,2,9,7,1,5,4]
    ret_list = mergesort(a_list)
    print(ret_list)

快速排序

def quick_sort(data):
    if len(data)>1:
        mid = data[0]
        left, right = [], []
        data.remove(mid)
        for num in data:
            if num < mid:
                left.append(num)
            else:
                right.append(num)
        return quick_sort(left) + [mid] + quick_sort(right)
    else:
        return data

if __name__ == '__main__':
    array = [2,3,5,7,1,4,6,15,5,2,7,9,10,15,9,17,12]
    print(quick_sort(array))

折半查找

代码略。

分治法解凸包问题
正如书上所说，实际上存在着好几个凸包问题的分治算法。这里只介绍了一种最简单的算法，它并不是效率最高的哦。而且它的操作和快排的操作很像，也叫快包。
书上写的太多了，我写一下我对该算法的理解。结合图和文字看。

假设P1、P2…Pn是平面上的点，点集合为S，同时这些点还是按照x、y的升序来排列的。
不难证明，点集合最左边的点P1和最右边的点Pn必然是凸包的顶点。则向量P1Pn（有方向的，不要忽略）就把S中的点分成了两部分，S1为左侧点的集合，S2为右侧点的集合。可想而知，分治求解，找到S1的凸包，这里称为上包，相应的S2的称为下包。
上包构造：
1.找到在S1中距离向量P1Pn最远的点，设为Pmax。
2.连接P1、Pmax，记作向量P1Pmax，其左侧的点集合为S1.1。
3.连接Pmax、Pn，记作向量PmaxPn，其左侧点集合为S1.2。
对S1.1，S1.2同样做上述操作。下包同样如此构造。
跟快排像在哪里呢，你发现没有，快排是每次操作都确定一个点的最终位置，然后以他为界限对左右部分进行分治。快包操作它可以每次都能够确定一个极点的位置，即Pmax，然后根据Pmax，再划分，进行分治。快包和快排的效率时相同的，平均效率为O(nlogn)，最差效率为O(n^2)。

总结
分治法，将问题划分为若干个子问题，然后对子问题递归求解，再合并，从而求得原始问题的解。大部分分治算法的时间效率满足T(n)=aT(n/b)+f(n)。