排序算法--归并，堆，快速排序

排序算法–归并，堆，快速排序

归并排序

思路：分治

public class MergeSort {

    public static void main(String[] args) {
        int[] arr = {8,4,7,5,6,3,1,2};
        print(arr);
        sort(arr);
    }

    static void sort(int[] a){
        int mid = a.length/2;
        a = merge(Arrays.copyOfRange(a, 0, mid),Arrays.copyOfRange(a, mid, a.length));
        print(a);
    }

    static int[] merge(int[] a1, int[] a2){
        int[] a = new int[a1.length+a2.length];

        //如果数组长度大于1，则继续向下递归
        if(a1.length > 1){
            int mid = a2.length/2;
            a1 = merge(Arrays.copyOfRange(a1, 0, mid),Arrays.copyOfRange(a1, mid, a1.length) );
        }
        if(a2.length > 1){
            int mid = a2.length/2;
            a2 = merge(Arrays.copyOfRange(a2, 0, mid),Arrays.copyOfRange(a2, mid, a2.length) );
        }

        //如果两个数组长度等于1或者数组已经经过归并排序，则合并两个数组
        int i = 0, j = 0;

        //合并两个有序数组
        while (i < a1.length && j < a2.length){
            if(a1[i] <= a2[j]){
                a[i+j] = a1[i++];
            }else {
                a[i+j] = a2[j++];
            }
        }

        //将未排完的数组添加再合并数组的后面
        while (i < a1.length){
            a[i+j] = a1[i++];
        }
        while (j < a2.length){
            a[i+j] = a2[j++];
        }

        print(a);

        return a;
    }

    static void print(int[] a){
        for (int i : a) {
            System.out.print(i + " ");
        }
        System.out.println("
");
    }
}

快速排序

经典快速排序总是指定数组或者某部分的最后一个元素作为基准值，随机快速排序指定数组或者某一部分中的随机值作为基准值。

public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {5,3,7,9,10,2,2,3};
        print(arr);
        sort(arr, 0, arr.length-1);
    }

    static void sort(int[] a, int l, int r){

        if(l >= r) {
            return;
        }

        int[] index = partition(a, l, r);
        //递归排序左右两部分
        sort(a, l, index[0]-1);
        sort(a, index[1]+1, r);

    }

    /**
     *
     * @param a 数组
     * @param l 左边界
     * @param r 右边界
     * @return 返回小于基准值的和大于基准值的边界
     */
    static int[] partition(int[] a, int l, int r){
        //less ,more分别表示小于和大于基准值的边界。
        // 他们中间的表示等于基准值,取最右边为基准值
        int less = l, more = r;
        int p = a[r];
        while (l <= more){
            if(a[l] > p){
                swap(a, l, more--);
            }else if(a[l] < p){
                swap(a, l++, less++);
            }else {
                l++;
            }
        }
        print(a);
        return new int[]{less, more};
    }

    static void swap(int[] a, int i, int j){
        if (i == j) {
            return;
        }
        a[i] = a[i]+a[j];
        a[j] = a[i]-a[j];
        a[i] = a[i]-a[j];
    }

    static void print(int[] a){
        for (int i : a) {
            System.out.print(i + " ");
        }
        System.out.println("
");
    }
}