Java选择排序

直接选择排序
原理：每一次从无序区间选出最大(或最小)的一个元素，存放在无序区间的最后（或最前) ,直到全部待排序的数据元素排完 。
稳定性：不稳定
复杂度：
空间复杂度 O(1)
时间的复杂度 O(n^2)

    public static void selectSort(int[]array){
        for(int bound = 0; bound < array.length; bound++){
            for(int cur = bound + 1; cur < array.length; cur++){
                int tmp = array[bound];
                if(array[cur] < tmp){
                    array[bound] = array[cur];
                    array[cur] = tmp;
                }
            }
        }
    }

堆排序
原理：首先用给定得元素建立堆，堆建立成功，交换第一个和最后一个元素，然后这个最后一个元素就算排序成功了。
稳定性：不稳定
复杂度：
空间复杂度：O(1)
时间复杂度：O(n * log(n))

    public static void heapSort(int[] array){
        createHeap(array);
        for(int i = 0; i < array.length; i++){
            swap(array, 0, array.length - i - 1);
            shiftDown(array, array.length - i - 1,0);
        }
    }
    public static void createHeap(int[] array){
        for(int i = (array.length - 1 - 1) / 2; i >= 0; i--){
            shiftDown(array, array.length, i);
        }
    }
    public static void shiftDown(int[]array, int size, int index){
        int parent = index;
        int child = 2 * parent + 1;
        while(child < size){
            if(child + 1 <size && array[child + 1] > array[child]){
                child = child + 1;
            }
            if(array[child] > array[parent]){
                swap(array, child, parent);
            }else{
                break;
            }
            parent = child;
            child = 2 * parent + 1;
        }
    }
    public static void swap(int[] array, int x, int y){
        int tmp = array[x];
        array[x] = array[y];
        array[y] = tmp;
    }