分治法

分治法是一种把大问题分解为小问题逐个求解，再把结果合并的解决方案，分治法衍生出的算法包含二分查找、合并排序、快速排序等，今天对这些算法逐个进行学习。

二分查找（BinarySearch）

算法要求

1.必须使用顺序表存储结构。
2.必须有序。

算法描述

首先将顺序表中间位置的值和目标值做比较，若相等则返回，否则以此位置将顺序表分为左右两部分，如果中间位置的值大于目标值则查找左子表，反之查找右子表，重复这一过程直至找到或遍历结束。

代码实现

    /**
     * 基于递归的二分查找
     * @param array 目标数组
     * @param key 要查找的数
     * @param beginIndex 起始索引
     * @param untilIndex 结束索引（不包含）
     * */
    public static int binarySearchRecursive(int[] array, int key, int beginIndex, int untilIndex){
        if(array == null)
            throw new IllegalArgumentException("target array is empty");
        int endIndex = untilIndex - 1;
        if(beginIndex > endIndex){
            return -beginIndex;
        }
        int midIndex = (beginIndex + endIndex) >> 1;
        int mid = array[midIndex];
        if(mid == key){
            return midIndex;
        }else if(mid > key){
            //查找左半部
            return binarySearchRecursive(array, key, beginIndex, midIndex);
        }else{
            return binarySearchRecursive(array, key, midIndex + 1, untilIndex);
        }
    }
    /**
     * 基于迭代的二分查找
     * @param array 目标数组
     * @param key 要查找的数
     * @param beginIndex 起始索引
     * @param untilIndex 结束索引（不包含）
     * */
    public static int binarySearchIterate(int[] array, int key, int beginIndex, int untilIndex){
        if(array == null)
            throw new IllegalArgumentException("target array is empty");
        int endIndex = untilIndex - 1;
        while(endIndex > beginIndex - 1){
            int midIndex = (beginIndex + endIndex) >> 1;
            int mid = array[midIndex];
            if(mid == key)
                return midIndex;
            else if(mid > key)
                return binarySearchIterate(array, key, beginIndex, midIndex);
            else
                return binarySearchIterate(array, key, midIndex + 1, untilIndex);
        }
        return -beginIndex;
    }

写这个算法其实我是翻车过好几次的。第一次我想，参数列表只有要查找的值和目标数组就好了嘛。结果到子过程就gg，一是左右子数组需要创建新的，二是最后返回的索引不好处理。第二次翻车则是因为写递归实现时边界值传错了导致遍历不完全漏掉了某些值，这个算法的左右边界值在设计时应该设计成左闭右开区间，子过程传递参数也要注意这点。

快速排序

算法要求

不适用链表结构

算法描述

1.首先定义两个指针指向左右两端（或者索引），取左边第一个元素作为参考值x，右指针向左依次遍历，如果遇到小于x的，就将这个值复制到左指针的位置，然后右指针不动，左指针依次向右遍历，如果遇到大于x的，就复制到右指针的位置，重复此过程直到两个指针重合，然后将参考值x复制到指针重合的位置，这个时候，x左边都是小于x的值，数组右边都是大于x的值。这个过程也可以从右边取，这样的话逻辑就反过来。
2.对x左右两侧的子数组分别执行过程1。
3.到没有子数组可分割，排序结束。

代码实现

    public static void quickSort4Array(int[] array, int begin, int end){
        if(array == null)
            throw new IllegalArgumentException("array is null");
        if(begin < 0)
            throw new IllegalArgumentException("begin index can not less than zero");
        if(end > array.length - 1)
            throw new IllegalArgumentException("end index exceed max");
        if(begin >= end)
            return;
        //参考值
        int x = array[begin];
        //左指针
        int leftPointer = begin;
        //右指针
        int rightPointer = end;
        //遍历方向
        boolean rightToLeft = true;
        while(leftPointer < rightPointer){
            if(rightToLeft){
                int curRightVal = array[rightPointer];
                while (curRightVal > x && rightPointer > leftPointer){
                    curRightVal = array[--rightPointer];
                }
                if(curRightVal <= x)
                    array[leftPointer] = curRightVal;
            }else{
                int curLeftVal = array[leftPointer];
                while (curLeftVal < x && leftPointer < rightPointer){
                    curLeftVal = array[++leftPointer];
                }
                if(curLeftVal >= x)
                    array[rightPointer] = curLeftVal;
            }
            rightToLeft = !rightToLeft;
        }
        array[leftPointer] = x;
        quickSort4Array(array, begin, leftPointer - 1);
        quickSort4Array(array, leftPointer + 1, array.length - 1);
    }