7種排序算法（java）——第二遍

public class bubbleSort {

    public final static int totalCount = 12;
    public final static int descAsc = 1;// 升序或者降序

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer[] initNum = new Integer[totalCount];
        int[] initNumo = new int[totalCount];

        for (int i = 0; i < totalCount; i++) {
            initNumo[i] = (int) (Math.random() * 100);
            initNum[i] = Integer.valueOf((int) (Math.random() * 100));
        }
        printNums(initNumo);
        System.out.println("++++++++++++++");

        SortAlgorithm4(initNumo);

        printNums(initNumo);
    }

    // 冒泡排序
    public static void SortAlgorithm1(int initNum[]) {
        int temp = -1;
        for (int i = 0; i < initNum.length; i++) {
            for (int j = 0; j < initNum.length - i - 1; j++) {// 注意不要越界
                if (initNum[j] > initNum[j + 1]) {
                    temp = initNum[j + 1];
                    initNum[j + 1] = initNum[j];
                    initNum[j] = temp;
                }
            }

        }
    }

    // 選擇排序
    public static void SortAlgorithm2(int initNum[]) {

        int temp = -1;
        for (int i = initNum.length - 1; i >= 0; i--) {
            int key = 0;
            for (int j = 0; j <= i; j++) {
                if (initNum[j] > initNum[key]) {
                    key = j;
                }
            }
            temp = initNum[i];
            initNum[i] = initNum[key];
            initNum[key] = temp;
        }
    }

    // 插入排序
    public static void SortAlgorithm3(int initNum[]) {
        int temp = 0;
        int k = 0;
        for (int i = 1; i < initNum.length; i++) {
            temp = initNum[i];
            k = i;
            while (k > 0 && temp < initNum[k - 1]) {
                initNum[k] = initNum[k - 1];
                k--;
            }
            initNum[k] = temp;          

        }

    }

    // 希爾排序；和步長直接相關
    public static void SortAlgorithm4(int initNum[]) {

        for(int j = initNum.length/2;j>0;j=j/2){
            int temp = 0;
            int k = 0;
            for (int i = j; i < initNum.length; i+=j) {
                temp = initNum[i];
                k = i;
                while (k > 0 && temp < initNum[k - j]) {
                    initNum[k] = initNum[k - j];
                    k-=j;
                }
                initNum[k] = temp;          

            }
        }

    }

    // 快速排序
    public static void SortAlgorithm5(int initNum[]) {
        quickSort(initNum, 0, initNum.length - 1);
    }

    public static void quickSort(int initNum[], int left, int right) {
        if (left < right) {
            int temp = initNum[left];// 這裏一定要先保存下來，因爲在遞歸的過程中數組的值是變化的，等遞歸回來的時候，值已經發生了變化，所以只能是用一個零時變量保存下來
            int low = left;
            int high = right;
            while (low < high) {
                while (low < high && initNum[high] >= temp) {
                    high--;
                }
                initNum[low] = initNum[high];
                while (low < high && initNum[low] <= temp) {
                    low++;
                }
                initNum[high] = initNum[low];
            }
            initNum[low] = temp;
            quickSort(initNum, left, low - 1);
            quickSort(initNum, low + 1, right);
        }
    }

    // 堆排序
    public static void SortAlgorithm6(int initNum[]) {
        int temp = -1;
        // 先初始化爲大頂堆
        for (int i = initNum.length / 2 - 1; i >= 0; i--) {
            heapSort(initNum, i, initNum.length - i - 1);
        }
        // 循環處理，講最大的數放到最後
        for (int j = initNum.length - 1; j >= 0; j--) {
            temp = initNum[j];
            initNum[j] = initNum[0];
            initNum[0] = temp;
            heapSort(initNum, 0, j - 1);
        }
    }

    // 調整堆使其成爲大頂堆;index 從0開始
    public static void heapSort(int initNum[], int node, int heapSize) {
        int left = node * 2 + 1;
        int right = node * 2 + 2;
        int maxTemp = node;
        if (left < heapSize) {
            heapSort(initNum, left, heapSize);
        }
        if (right < heapSize) {
            heapSort(initNum, right, heapSize);
        }
        if (left <= heapSize && initNum[left] > initNum[maxTemp]) {
            maxTemp = left;
        }
        if (right <= heapSize && initNum[right] > initNum[maxTemp]) {
            maxTemp = right;
        }
        if (maxTemp != node) {
            int temp = initNum[node];
            initNum[node] = initNum[maxTemp];
            initNum[maxTemp] = temp;
        }
    }

    // 歸併排序
    public static void SortAlgorithm7(int initNum[]) {
        mergeSort(initNum, 0, initNum.length - 1);
    }

    // 歸併遞歸
    public static void mergeSort(int initNum[], int start, int end) {
        int middle = (start + end) / 2;
        if (start < end) {
            mergeSort(initNum, start, middle);
            mergeSort(initNum, middle + 1, end);
            mergeMethed(initNum, start, middle, end);
        }
    }

    // 合併方法
    public static void mergeMethed(int initNum[], int start, int middle, int end) {
        int low1 = start;

        int low2 = middle + 1;

        int k = 0;

        int initTemp[] = new int[end - start + 1];

        while (low1 <= middle && low2 <= end) {
            if (initNum[low1] <= initNum[low2]) {
                initTemp[k] = initNum[low1];
                low1++;
                k++;
            } else {
                initTemp[k] = initNum[low2];
                low2++;
                k++;
            }
        }
        while (low1 <= middle && low2 > end) {
            initTemp[k] = initNum[low1];
            low1++;
            k++;
        }
        while (low1 > middle && low2 <= end) {
            initTemp[k] = initNum[low2];
            low2++;
            k++;
        }
        for (int i = 0; i < initTemp.length; i++, start++) {
            initNum[start] = initTemp[i];
        }

    }

    public static void printNums(int initNum[]) {
        for (int i = 0; i < initNum.length; i++) {
            System.out.println("" + initNum[i]);
        }

    }

    public static void printNumsln(int initNum[]) {
        for (int i = 0; i < initNum.length; i++) {
            System.out.print("  " + initNum[i]);
        }

    }
}