《数据结构与算法之美》32——分治算法

如何理解分治算法

分治算法（divide and conquer）的核心思想就四个字：分而治之，就是将原问题划分成 n 个规模较小，并且结构与原问题相似的子问题，递归地解决这些子问题，然后再合并其结果，就得到原问题的解。

这个定义看起来有点类似递归的定义。分治和递归的区别是，分治算法是一种处理问题的思想，递归是一种编程技巧。实际上，分治算法一般比较适合用递归来实现。

分治算法的递归实现中，每一层递归都会涉及三个操作：

• 分解：将原问题分解成一系列子问题；
• 解决：递归地求解各个子问题，若子问题足够小，则直接求解；
• 合并：将子问题的结果合并成原问题；

分治算法能解决的问题，一般需要满足下面这几个条件：

• 原问题与分解成的小问题具有相同的模式；
• 原问题分解成的子问题可以独立求解，子问题之间没有相关性；
• 具有分解终止条件；
• 可以将子问题合并成原问题，并且这个拿着操作的复杂度不能太高；

分治算法应用举例分析

假设我们有 n 个数据，我们期望数据从小到大排列，那完全有序的数据的有序度就是 ，逆序度等于0；相反，倒序排列的数据的有序度就是0，逆序度是 。除了这两种 极端情况外，我们通过计算有序对或者逆序对的个数，来表示数据的有序度或逆序度。

如何编程求出一组数据的有序对个数或者逆序对个数呢？

image

最笨的方法是，拿每个数字跟它后面的数字比较，看有几个比它小的。我们把比它小的数字 个数记作 k，通过这样的方式，把每个数字都考察一遍之后，然后对每个数字对应的k值求 和，最后得到的总和就是逆序对个数。不过，这样操作的时间复杂度是 。

套用分治思想来求数组A的逆序对个数。我们可以将数组分成 前后两半 A1 和 A2，分别计算A1和A2的逆序对个数 K1 和 K2，然后再计算A1与A2之间的逆序对 个数 K3。那数组A的逆序对个数就等于 K1+K2+K3。

使用归并排序算法来快速计算出两个子问题 A1 与 A2 之间的逆序对个数。求解过程如下图：

image

代码实现：

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 订单数据了。

参考资料

• 38 | 分治算法：谈一谈大规模计算框架MapReduce中的分治思想