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("++++++++++++++");

        SortAlgorithm7(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 = 0;

        for (int i = initNum.length - 1; i >= 0; i--) {
            int max = 0;// 这个值很关键
            for (int j = 0; j <= i; j++) {
                if (initNum[j] > initNum[max]) {
                    max = j;
                }
            }
            temp = initNum[i];
            initNum[i] = initNum[max];
            initNum[max] = temp;
        }

    }

    // 插入排序，插入已经有序队列;按照算法一步一步算下来
    public static void SortAlgorithm3(int initNum[]) {
        int temp = 0;

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

    }

    // 希尔排序；局部有序，排序更快，和步长直接相关；建立在插入排序之上
    public static void SortAlgorithm4(int initNum[]) {
        int temp = 0;
        for (int n = initNum.length / 2; n > 0; n = n / 2) {
            for (int i = n; i < initNum.length; i += n) {
                int j = 0;
                temp = initNum[i];
                while (initNum[j] < temp) {
                    j += n;
                }
                for (int k = i; k > j; k -= n) {
                    initNum[k] = initNum[k - n];
                }
                initNum[j] = 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 low = left;
            int high = right;
            int temp = initNum[left];
            while (low < high) {
                while (low < high && initNum[high] > temp) {// 注意添加low<high这个条件，外面的那个限制不能作用到里面
                    high--;
                }
                initNum[low] = initNum[high];
                while (low < high && initNum[low] <= temp) {
                    low++;
                }
                initNum[high] = initNum[low];
            }
            initNum[high] = temp;
            quickSort(initNum, left, low - 1);
            quickSort(initNum, low + 1, right);
        }

    }

    // 堆排序
    public static void SortAlgorithm6(int initNum[]) {
        int temp = 0;
        // 1、生成大顶堆
        for (int i = initNum.length / 2 - 1; i >= 0; i--) {
            createHeap(initNum, i, initNum.length - 1);
        }
        for (int j = initNum.length - 1; j >= 0; j--) {
            temp = initNum[j];
            initNum[j] = initNum[0];
            initNum[0] = temp;
            createHeap(initNum, 0, j - 1);
        }
    }

    // 插入一个数字到打定堆中
    public static void createHeap(int initNum[], int firstNode, int lastNode) {

        if (firstNode < lastNode) {
            int leftNode = firstNode * 2 + 1;
            int rightNode = firstNode * 2 + 2;
            int maxNode = firstNode;
            int temp = -1;

            if (leftNode <= lastNode && initNum[leftNode] > initNum[maxNode]) {
                maxNode = leftNode;
            }
            if (rightNode <= lastNode && initNum[rightNode] > initNum[maxNode]) {
                maxNode = rightNode;
            }
            if (maxNode != firstNode) {
                temp = initNum[firstNode];
                initNum[firstNode] = initNum[maxNode];
                initNum[maxNode] = temp;
            }
            createHeap(initNum, leftNode, lastNode);
            createHeap(initNum, rightNode, lastNode);
        }
    }

    // 归并排序
    public static void SortAlgorithm7(int initNum[]) {
        recursionMethed(initNum,0,initNum.length-1);
    }

    public static void recursionMethed(int initNum[], int start, int end) {
        if(start<end){  
            recursionMethed(initNum,start,(start+end)/2);
            recursionMethed(initNum,(start+end)/2+1,end);//分两段是切断了的
            mergeMethed(initNum,start,(start+end)/2,end);    
        }
    }

    // 处理相邻的两个有序数组
    public static void mergeMethed(int initNum[], int start, int middle, int end) {
        if (start == middle && middle == end) {
            return;
        }
        int tempNums[] = new int[end - start + 1];
        int firstTemp = start;
        int secoundTemp = middle+1;//分开切断
        int k = 0;
        while (firstTemp <= middle && secoundTemp <= end) {
            if (initNum[firstTemp] <= initNum[secoundTemp]) {
                tempNums[k] = initNum[firstTemp];
                k++;
                firstTemp++;
            } else {
                tempNums[k] = initNum[secoundTemp];
                k++;
                secoundTemp++;
            }
        }
        while (firstTemp > middle && secoundTemp <= end) {
            tempNums[k] = initNum[secoundTemp];
            k++;
            secoundTemp++;
        }
        while (firstTemp <= middle && secoundTemp > end) {
            tempNums[k] = initNum[firstTemp];
            k++;
            firstTemp++;
        }
        // 将排完序的数组赋值回去
        for (int i = 0, s = start; i < tempNums.length; i++, s++) {
            initNum[s] = tempNums[i];
        }
    }

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

    }

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

    }
}