算法：分治算法

如何理解“分治算法”

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

这个问题看起来有点类似递归的定义，那递归和分治有什么区别呢？分治算法是一种处理问题的思想，递归是一种编程技巧。实际上，分治算法一般都比较适合用递归来实现。分治算法的递归实现中，每一层递归都会涉及这样三个操作：

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

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

• 原问题与分解成的小问题具有相同的模式
• 原问题分解成的子问题可以独立求解，子问题之间没有相关性，这一点是分治算法跟动态算法最大的区别
• 具有分解终止条件，也就是说，当问题足够小的时候，可以直接求解
• 可以将子问题合并成原问题，而且这个合并操作的复杂度不能太高，否则就起不到减小算法总体复杂度的效果了

分治算法求解逆序对

问题

在排序算法中，可以用有序度来表说一组数据的有序程度，用逆序度表示一组数据的无序程度。

• 有序度是数组中具有有序关系的元素对的个数。
• 比如说2、4、3、1、5、6这组数组的有序度是11，因为它有11个有序元素对，分别是(2,4)、(2,3)、(2,5) (2,6)、(4,5)、(4,6)、(3,5)、(3,6)、(1,5)、(1,6)、(5,6)。
• 对于6、5、4、3、2、1这组数据，它的有序度是0；对于1、2、3、4、5、6这组数据来说，它的有序度是n*(n-1)/2，这种完全有序的数组的有序度叫做满有序度。
• 所以逆序度也就等于满有序度-有序度，排序的过程就是增加有序度，减少逆序度的过程，最后到达满有序度，排序就结束了。

假设我们有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，然后再计算A1与A2之间的逆序对个数K3，那数组A的逆序对个数就等于K1+K2+K3。

使用分治算法其中一个要求是，子问题合并的代码不能太大，否则就起不了降低时间复杂度的效果了。那回到这个问题，如何快速计算出两个子问题A1与A2之间的逆序对个数呢？

这就要借助归并排序算法了。归并排序中有一个关键的操作，就是将两个有序的小数组，合并成一个有序的数组。实际上，在这个合并的过程中，我们就可以计算这两个小数组的逆序对个数了。每次合并操作，我们都计算逆序对个数，把这些计算出来的逆序对个数求和，就是这个数组的逆向对个数了。

  private int num = 0; //全局变量

    public int count(int[] a, int  n){
        num = 0;
        memgeSortCounting(a, 0, n - 1);
        return num;
    }

    private void memgeSortCounting(int []a, int p, int r){
        if(p >= r){
            return;
        }
        int q = (p + r) / 2;
        memgeSortCounting(a, p, q);
        memgeSortCounting(a, q + 1, r);
        merge(a, p, q, r);
    }

    private void merge(int [] a, int p, int q, int r){
        int i = p, j = q + 1, k = 0;
        int [] tmp = new int[r - p + 1];
        while (i <= q && j <= r){
            if(a[i] <= a[j]){
                tmp[k++] = a[i++];
            }else{
                num += (q - i + 1); //统计p-q之间，比a[j]大的元素个数
                tmp[k++] = a[j++];
            }
        }
        
        while (i <= q){  //处理剩下的
            tmp[k++] = a[i++];
        }
        while (j <= r){ //处理剩下的
            tmp[k++] = a[j++];
        }
        for(i = 0; i <= r-p; ++i){ // 从tmp拷贝回a
            a[p + i] = tmp[i];
        }
    }

分治思想在海量数据处理中的应用

比如，给 10GB 的订单文件按照金额排序这样一个需求，看似是一个简单的排序问题，但是因为数据量大，有 10GB，而我们的机器的内存可能只有 2、3GB 这样子，无法一次性加载到内存，也就无法通过单纯地使用快排、归并等基础算法来解决了。

要解决这种数据量大到内存装不下的问题，我们就可以利用分治的思想。我们可以将海量的数据集合根据某种方法，划分成几个小的数据集合，每个小的数据集合单独加载到内存中仅仅，然后再将小数据集合合并成大数据集合。实际上，利用这种分治的处理思路，不仅仅能克服内存的限制，还能利用多线程或者多机处理，加快处理的速度。

比如刚刚的例子，给10GB的订单排序，我们就可以先扫描一遍订单，根据订单的金额，将10GB的文件划分为几个金额区间。比如订单金额为1到100元的放到一个小文件，101到200之间的放到另一个文件，以此类推。这样每个小文件都可以单独加载到内存排序，最后将这些有序的小文件合并，就是最终有序的10GB订单数据了。

如果订单数据存储在类似GFS这样的分布式系统上，当10GB的订单被划分成多个小文件的时候，每个文件可以并行的加载到多台机器上处理，最后再将结果合并到一起，这样并行处理的速度也加快了很多。不过，这里有一点要注意，就是数据的存储与计算所在的机器是同一个或者在网络中靠的很近（比如一个局域网内，数据存取速度很快），否则就会因为数据访问的速度，导致整个处理过程不但不会变快，反而会变慢。

为什么说MapReduce的本质就是分治思想

实际上，MapReduce框架只是一个任务调度器，底层依赖GFS来存储数据，依赖Borg管理机器。它从GFS中拿数据，交给Borg中的机器执行，并且时刻监控机器执行的进度，一旦出现机器宕机、进度卡壳等，就重新从Borg中调度一台机器执行。