排序算法

package sort;

/**
 * @Description
 * @Author Created by t.wu on 2017/8/21.
 */
public class QuickSort {

    public void sort(int[] a, int l, int r) {
        if (l < r) {
            int split = partition(a, l, r);
            sort(a, l, split);
            sort(a, split + 1, r);
        }
    }

    /**
     * 直接就地把小于pivot的数顺序放到a的起始位置
     * @param a
     * @param l
     * @param r
     * @return
     */
    public static int partition(int[] a, int l, int r) {
        int pivot = a[r];
        int i = l - 1;
        int j;
        for (j = l; j <= r - 1; j++) {
            if (a[j] <= pivot) {
                i++;
                int temp = a[i];
                a[i] = a[j];
                a[j] = temp;
            }
        }
        // 这时i的左边都是小于 pivot的，所以把i+1的位置和pivot调换
        pivot = a[i + 1];
        a[i + 1] = a[r];
        a[r] = pivot;
        return i + 1;
    }
}

package sort;

/**
 * @Description 堆排序
 * 算法思想：
 * @Author Created by t.wu on 2017/8/21.
 */
public class HeapSort {

    /**
     * 保证任意节点的值都大于其子节点的值
     * 如何保证这个树的中任意节点都有左右两个子节点？
     * 答案就在建树的过程中。
     * 注意 数组索引从0开始，左右子树的索引正确的算法，就应该分别是 2 * 1 + 1 , 2 * i + 2
     * @param a
     * @param heapSize
     * @param index
     */
    public void heapfy(int[] a, int heapSize, int index) {
        int left = 2 * index +1;
        int right = 2 * index + 2;
        int max = index;
        if (left < heapSize && a[max] < a[left]) {
            max = left;
        }
        if (right < heapSize && a[max] < a[right]) {
            max = right;
        }
        if (max != index) {
            int tmp = a[index];
            a[index] = a[max];
            a[max] = tmp;
            heapfy(a, a.length, max);
        }
    }

    public void createHeap(int[] a) {
        int middle = a.length / 2 -1;
        for (int i = middle; i >= 0; i--) {
            heapfy(a, a.length,i);
        }
    }

    /**
     * 取出最大的a[0]，放在最后，再对剩下的数组进行heapfy。
     * @param a
     */
    public void sort(int[] a){
        for(int i = a.length-1 ; i >=0 ; i--){
            int tmp = a[0];
            a[0] = a[i];
            a[i] = tmp ;

            heapfy(a,i,0);
            System.out.println("====dd====");
            for(int j : a){
                System.out.print(j+" ");
            }
        }
    }

    public static void main(String[] args) {
        int[] a = new int[] {17,13,4,51,67,5};
        HeapSort hs = new HeapSort();
        hs.createHeap(a);
        hs.sort(a);
        System.out.println("========");
        for(int i : a){
            System.out.print(i+" ");
        }
    }
}

package sort;

/**
 * @Description 插入排序
 * 算法思想：从数组第二个位置开始，以当前位置的值和其前面所有值进行比较，凡是比当前值大的都向后移一位。
 * @Author Created by t.wu on 2017/8/19.
 */
public class InsertSort {
    /**
     *
     * @param a
     */
    public void sort(int[] a){
        for(int i=1; i<a.length ; i++){
            int pivot = a[i];
            int j = i-1;
            while(j>=0 && a[j]> pivot){
                a[j+1] = a[j];
                j--;
            }
            // 跳出循环，意味着 j=-1<0 or a[j] < pivot,
            // j=-1时，j+1 = 0 ,也就从j >=1 开始的位置逗比 pivot大，则a[0] = pivot
            // a[j] < pivot 意味着 a[j+1] 开始都大于pivot，原来的j+1位置因为大于pivot，所以已经后移了，这时j+1的位置其实是“空”的。
            // 所以pivot 放在j+1 正好，前面都比他小，后面都比他大。
             a[j+1] = pivot;
        }
    }

    public static void main(String[] args) {
        int[] a = new int[] {17,13,4,51,67,5};
        new InsertSort().sort(a);
        for(int i : a){
            System.out.println(i);
        }
    }
}

package sort;

/**
 * @Description 归并排序
 * 算法思想：想象两叠牌，两叠牌都是有序的，如何让他们合并成一个有序的数列？
 * 1. 首先二分数组 length /2  并下取整。
 * 2. 每次从左右队列中各取一个数，进行比较，小的放进原数组的相应位置。
 * 3. 注意：边界条件，当p>=r时，说明没有可再二分的数。所以一定是最先分到左右数组各有一个数为止，开始合并这两个数组。
 * @Author Created by t.wu on 2017/8/19.
 */
public class MergeSort {

    private void merge(int[] a , int p,int q, int r ){
        int n1 = q-p+1+1;
        int n2 = r-q+1;
        int[] left = new int[n1];
        int[] right = new int[n2];
        for(int i = 0 ; i< left.length-1; i++){
            left[i]= a[p+i];
        }
        for(int i = 0 ; i< right.length-1; i++){
            right[i]= a[q+1+i];
        }
        left[q-p+1] = Integer.MAX_VALUE;   // （1） 最大的数放在这里，方便比较且不会越界
        right[r-q] = Integer.MAX_VALUE;

        int j =0;
        int i =0;
        for(int k = p; k<=r; k++ ){
            if(left[i]<right[j]){   //（1）
                a[k] = left[i];
                i++;
            }else{
                a[k] = right[j];
                j++;
            }
        }
    }
    public void sort(int[] a,int p,int r ){
        if(p<r){
            int middle = (r+p)/2 ;
            sort(a,p,middle);
            sort(a,middle+1,r);
            merge(a,p,middle,r);
        }
    }
    public static void main(String[] args) {
        int[] a = new int[] {17,13,4,51,67,5};
        new MergeSort().sort(a,0,a.length-1);
        for(int i : a){
            System.out.print(i+" ");
        }
    }
}