如何理解分治算法
分治算法（divide and conquer）的核心思想就四个字：分而治之，就是将原问题划分成 n 个规模较小，并且结构与原问题相似的子问题，递归地解决这些子问题，然后再合并其结果，就得到原问题的解。
这个定义看起来有点类似递归的定义。分治和递归的区别是，分治算法是一种处理问题的思想，递归是一种编程技巧。实际上，分治算法一般比较适合用递归来实现。
分治算法的递归实现中，每一层递归都会涉及三个操作：
- 分解：将原问题分解成一系列子问题；
- 解决：递归地求解各个子问题，若子问题足够小，则直接求解；
- 合并：将子问题的结果合并成原问题；
分治算法能解决的问题，一般需要满足下面这几个条件：
- 原问题与分解成的小问题具有相同的模式；
- 原问题分解成的子问题可以独立求解，子问题之间没有相关性；
- 具有分解终止条件；
- 可以将子问题合并成原问题，并且这个拿着操作的复杂度不能太高；
分治算法应用举例分析
假设我们有 n 个数据，我们期望数据从小到大排列，那完全有序的数据的有序度就是 (n(n-1)/2)，逆序度等于0；相反，倒序排列的数据的有序度就是0，逆序度是 (n(n-1)/2)。除了这两种 极端情况外，我们通过计算有序对或者逆序对的个数，来表示数据的有序度或逆序度。
如何编程求出一组数据的有序对个数或者逆序对个数呢？
最笨的方法是，拿每个数字跟它后面的数字比较，看有几个比它小的。我们把比它小的数字 个数记作 k，通过这样的方式，把每个数字都考察一遍之后，然后对每个数字对应的k值求 和，最后得到的总和就是逆序对个数。不过，这样操作的时间复杂度是 (O(n^2))。
套用分治思想来求数组A的逆序对个数。我们可以将数组分成 前后两半 A1 和 A2，分别计算A1和A2的逆序对个数 K1 和 K2，然后再计算A1与A2之间的逆序对 个数 K3。那数组A的逆序对个数就等于 K1+K2+K3。
使用归并排序算法来快速计算出两个子问题 A1 与 A2 之间的逆序对个数。求解过程如下图：
代码实现：
var num = 0 // 全局变量或者成员变量
func count(a []int, n int) int {
num = 0
mergeSortCounting(a, 0, n-1)
return num
}
func mergeSortCounting(a []int, p int, r int) {
if p >= r {
return
}
q := (p + r) / 2
mergeSortCounting(a, p, q)
mergeSortCounting(a, q+1, r)
merge(a, p, q, r)
}
func merge(a []int, p int, q int, r int) {
i, j, k := p, q+1, 0
tmp := make([]int, r-p+1)
for i <= q && j <= r {
if a[i] <= a[j] {
tmp[k] = a[i]
k++
i++
} else {
num += (q - i + 1) // 统计p-q之间，比a[j]大的元素个数
tmp[k] = a[j]
k++
j++
}
}
for i <= q { // 处理剩下的
tmp[k] = a[i]
k++
i++
}
for j <= r { // 处理剩下的
tmp[k] = a[j]
k++
j++
}
for i := 0; i <= r-p; i++ { // 从tmp拷贝回a
a[p+i] = tmp[i]
}
}
分治思想在海量数据处理中的应用
分治算法思想的应用是非常广泛的,并不仅限于指导编程和算法设计。它还经常用在海量数据处理的场景中。前面讲的数据结构和算法，大部分都是基于内存存储和单机处理。但是，如果要处理的数据量非常大，没法一次性放到内存中，这个时候，这些数据结构和算法就无法工作了。
比如，给 10GB 订单文件按照金额排序，而机器的内存可能只有 2、3GB，无法一次性加载到内存，就无法单纯地使用快排、归并等基础算法来解决了。
要解决这种数据量大到内存装不下的问题，可以使用分治思想。将海量的数据集合划分成几个小的数据集合，每个小的数据集合能够单独加载到内存来解决，然后再将小数据集合合并成大数据集合。
比如刚刚举的那个例子，给 10GB 的订单排序，我们就可以先扫描一遍订单，根据订单的金 额，将 10GB 的文件划分为几个金额区间。比如订单金额为 1 到 100 元的放到一个小文件，101 到 200 之间的放到另一个文件，以此类推。这样每个小文件都可以单独加载到内存排序，最后将 这些有序的小文件合并，就是最终有序的 10GB 订单数据了。