分治算法-归并排序、快速排序

分治算法：把一个任务，分成形式和原任务相同，但规模更小的几个部分任务（通常是两个部分），分别完成，或只需要选一部完成。然后再处理完成后的这一个或几个部分的结果，实现整个任务的完成。

分治的典型应用：归并排序、快速排序

---

归并排序动态图：

package com.inbreak.cnblogs.sort;

import com.inbreak.cnblogs.Helper;

/**
 * 归并排序：
 * 分别前一半、后一半排序
 * 将前半部分、后半部分归并到一个有序数组，再拷贝到原数组中。
 *
 * @author inbreak
 * @create 2018-07-19
 */
public class MergeSort {

    public static void main(int[] a, int size) {
        Helper.printArray(a);
        int[] tmp = new int[size];
        mergeSort(a, 0, size - 1, tmp);
        Helper.printArray(a);
    }

    public static void mergeSort(int[] a, int s, int e, int[] tmp) {
        if (s < e) {
            int m = (s + e) / 2;
            mergeSort(a, s, m, tmp);
            mergeSort(a, m + 1, e, tmp);
            merge(a, s, m, e, tmp);
        }
    }

    public static void merge(int[] a, int s, int m, int e, int[] tmp) {
        //将s~m和m+1~e合并到tmp数组
        int pt = 0;
        int pi = s;
        int pj = m + 1;
        //先把左半边或者右半边的拷贝完
        while (pi <= m && pj <= e) {
            if (a[pi] < a[pj]) {
                tmp[pt++] = a[pi++];
            } else {
                tmp[pt++] = a[pj++];
            }
        }
        //上面的while循环结束，其中的一半全部复制完成，下面的2个while循环只有一个会走
        //这趟归并的左半部分
        while (pi <= m) {
            tmp[pt++] = a[pi++];
        }
        //这趟归并的右半部分
        while (pj <= e) {
            tmp[pt++] = a[pj++];
        }
        //将tmp复制到原数组
        for (int i = 0; i < e - s + 1; i++) {
            a[s + i] = tmp[i];
        }
    }

}

---

 快速排序：

package com.inbreak.cnblogs.sort;

import com.inbreak.cnblogs.Helper;

/**
 * 快速排序：
 * 1）设k=a[0], 将k挪到适当位置，使得比k小的元素都在k左边,比k大的元素都在k右边，和k相等的，不关心在k左右出现均可 （O（n)时间完成）
 * 2) 把k左边的部分快速排序
 * 3) 把k右边的部分快速排序
 *
 * @author inbreak
 * @create 2018-07-19
 */
public class QuickSort {

    public static void main(int[] a, int size) {
        Helper.printArray(a);
        quickSort(a, 0, size - 1);
        Helper.printArray(a);
    }

    public static void quickSort(int[] a, int s, int e) {
        if (s >= e) {
            return;
        }
        int k = a[s];
        int pi = s;
        int pj = e;
        //while循环结束 pi == pj 后的这个就是a[pi] == k,确定这个左边数都比k小，右边都比k大
        while (pi != pj) {
            //先从右指针pj往左遍历
            while (pj > pi && a[pj] >= k) {
                pj--;
            }
            //pj循环结束后 pj中的值a[pj] < k,此时交换内容，因为默认第一个就是k也就是a[pi]
            Helper.swap(a, pi, pj);
            //从左指针pi往右遍历
            while (pj > pi && a[pi] <= k) {
                pi++;
            }
            //交换
            Helper.swap(a, pi, pj);
        }
        //针对左、右半部分的递归
        quickSort(a, s, pi - 1);
        quickSort(a, pi + 1, e);

    }
}