Java实现——选择排序、shell排序、合并排序、堆排序

    private void insertSort(int[] array){        int temp, j;        for(int i = 1; i < array.length; i++){            temp = array[i];            for(j = i; j >= 1 && array[j - 1] > temp; j--){                                    array[j] = array[j - 1];             }            array[j] = temp;        }    }

    /**     * shellSort, a kind of inserting sort     * @param array     */    private void shellSort(int[] array){        int increment, j, temp;        for(increment = array.length / 2; increment >= 1; increment /= 2){            for(int i = 0; i < increment; i++){                                for(j = i + increment; j < array.length; j += increment){                    if(array[j - increment] > array[j]){                        temp = array[j];                        int k;                        for(k = j - increment; k >=0 && array[k] > temp; k -= increment){                            array[k + increment] = array[k];                        }                        array[k + increment] = temp;                    }                                    }            }        }    }

    /**     * mergeSort     * @param array     * @param low     * @param high     */    private void mergeSort(int[] array, int low, int high){        int middle = (low + high) / 2;        if(low < high){            mergeSort(array, low, middle);            mergeSort(array, middle + 1, high);            merge(array, low, middle, high);        }    }        /**     *      * @param array     * @param low     * @param middle     * @param high     */    private void merge(int[] array, int low, int middle, int high){        int[] temp = new int[high - low + 1];        int i = low;        int j = middle + 1;        int k = 0;        while(i <= middle && j <= high){            if(array[i] < array[j]){                temp[k] = array[i];                k++;                i++;            }else{                temp[k] = array[j];                k++;                j++;            }        }        while(i <= middle){            temp[k] = array[i];            k++;            i++;        }        while(j <= high){            temp[k] = array[j];            k++;            j++;        }        for(int m = 0; m < temp.length; m++){            array[low + m] = temp[m];        }    }

    /**
     * heap sort, 一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。
     * 如第0个结点左右子结点下标分别为1和2。
     * @param args
     */
    private void adjustHeap(int[] array){
        int length = array.length;
        int k, temp;
        int parent = (array.length - 1 - 1) / 2;
        k = max(array, array.length - 1);
        if(k != parent){
            temp = array[parent];
            array[parent] = array[k];
            array[k] = temp;
        }
        
        
    }
    /**
     * max, assistant function for heapSort
     * get index of max value among i, its brother and its parent
     * @param array
     * @param i
     * @return
     */
    private int max(int[] array, int i){// i is index of child node
        int temp = array[i];
        int k = i;
        int parent = (i - 1) / 2;//parent index
        if(array.length - 1 >= 2 * parent + 2){//if brother node exists
            if(temp < array[2 * parent + 2]){
                temp = array[2 * parent + 2];
                k = 2 * parent + 2;
            }
        }
        if(temp < array[parent]){
            k = parent;
        }
        return k;
    }
    
    /**
     * assistant function for heapSort
     * @param array
     * @param i
     * @param k
     */
    private void swap(int[] array, int i, int k){
        int temp = array[i];
        array[i] = array[k];
        array[k] = temp;
    }
    
    /**
     * assistant function for heapSort
     * @param array
     * @param lastIndex
     */
    private void buildMaxHeap(int[] array, int lastIndex){
        for(int i = (lastIndex - 1) / 2; i >= 0; i--){//from parent node of last element on
            int k = i;
            while(2 * k + 1 <= lastIndex){//if left child node exists
                int biggerIndex = 2 * k + 1;
                if(biggerIndex + 1 <= lastIndex){//if right child node exists
                    if(array[biggerIndex] < array[biggerIndex + 1]){
                        biggerIndex++;//biggerIndex is index of bigger child nodes
                    }
                }
                if(array[k] < array[biggerIndex]){//if parent value less than child value
                    swap(array, k, biggerIndex);//switch them 
                    k = biggerIndex;//for next loop, make sure value for k larger than child values
                }else{
                    break;
                }                
            }
        }
    }
    
    /**
     * heapSort
     * @param array
     */
    private void heapSort(int[] array){
        for(int i = array.length - 1; i > 0; i--){
            buildMaxHeap(array, i);//build max heap and index of largest value is 0
            swap(array, 0, i);//switch largest value to last
        }
    }
    
    /**
     * get number in some position
     * @param num
     * @param pos
     * @return
     */
    private int getNumInPos(int num, int pos){
        int temp = 1;
        for(int i = 1; i < pos; i++){
            temp *= 10;
        }
        return (num / temp) % 10;
    }
    
    /**
     * assistant function for heapSort
     * get max weishu 
     * @param array
     * @return
     */
    private int getMaxWeishu(int[] array){
        int max = array[0];
        int d = 10, k = 1;
        for(int i = 0; i < array.length; i++){
            if(max < array[i]){
                max = array[i];
            }            
        }
        while(true){
            if(max / d != 0){
                d *= 10;
                k++;
            }else{
                break;
            }
        }
        return k;
    }
    
    /**
     * assistant function for heapSort
     * @param array
     * @param d
     */
    private void radixSort(int[] array, int d){
        int[][] a = new int[10][array.length + 1];
        for(int i = 0; i < 10; i++){
            a[i][0] = 0;
        }
        for(int pos = 1; pos <= d; pos++){            
            for(int i = 0; i < array.length; i++){
                int row = getNumInPos(array[i], pos);
                int col = ++a[row][0];
                a[row][col] = array[i];
            }
            for(int row = 0, i = 0; row < 10; row++){
                for(int col = 1; col <= a[row][0]; col++){
                    array[i++] = a[row][col];
                }
                a[row][0] = 0;
            }
        }
    }