排序（2）

快速排序

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

private static void quickSortInter(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }
        int p = partition1(array, left, right);
        quickSortInter(array, left, p - 1);
        quickSortInter(array, p + 1, right);

    }

继续来看partition怎么实现

partition就是选一个基准，小的都在左边，大的都在右边
实现图如下：

选6位基准值，先右边走，如果碰到比6小的停下来，之后左边走，碰到比6大的停下来，停下来之后交换。

这是一次交换之后的结果。

这是整个partition之后的结果。
下面是三种解法

 private static int partition1(int[] a, int left, int right) {
        int begin = left;
        int end = right;
        int pivot = a[left];
        while (begin < end) {
            while (begin < end && a[end] >= pivot) {
                end--;
            }
            while (begin < end && a[begin] <= pivot) {
                begin++;
            }
            swap(a, begin, end);
        }
        swap(a, left, begin);
        return begin;

    }

private static int partition2(int[] array, int left, int right) {

        int begin = left;
        int end = right;
        int p = array[left];
        while (begin < end) {
            while (begin < end && array[end] >= p) {
                end--;
            }
            array[begin] = array[end];
            while (begin < end && array[begin] < p) {
                begin++;
            }
            array[end] = array[begin];
        }
        array[begin]=p;
        return begin;
    }

private static int partition3(int[] array,int left,int right){
        int p=array[left];
        int d = left + 1;
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < p) {
                swap(array, i, d++);
            }
        }
        swap(array, d - 1, left);
        return d - 1;
    }

归并排序
建立在归并操作上的一种有效的排序算法,该算法是采用分治的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

代码：

public class MergeSort {
    public static void mergeSort(int[] array) {
        mergeSortInter(array, 0, array.length);
    }

    public static void mergeSortInter(int[] array, int low, int high) {
        if (low >= high - 1) {
            return;
        }
        int mid = (low + high) / 2;
        mergeSortInter(array, low, mid);
        mergeSortInter(array, mid, high);
        merge(array, low, mid, high);
    }

    private static void merge(int[] array, int low, int mid, int high) {
        int p1 = low;
        int p2 = mid;
        int[] brr=new int[20];
        int i=0;
        int length=high-low;

        while (p1 < mid && p2 < high) {

            if (p1 <= p2) {
                array[i] = p1;
                i++;
                p1++;
            } else {

                    array[i] = p2;
                    i++;
                    p2++;


            }
        }
        while(p1<mid){
            brr[i++]=array[p1++];
        }
        while(p2<high){
            brr[i++]=array[p2++];
        }
        for(int x=0;x<length;x++){
            array[low+x]=brr[x];
        }
    }



//  非递归方法
    public static void MergrSort3(int[] array){
        for(int i=1;i<array.length;i=i*2){
            for(int j=0;j<array.length;j=j+i*2){
                int low=j;
                int mid=j+i;
                if(mid>=array.length){
                    continue;
                }
                int high=mid+i;
                if(high>array.length){
                    high=array.length;
                }
                merge(array,low,mid,high);
            }
        }
    }
}

各种排序总结：