7种排序算法（java）——第五遍（）

package com.luojie;

/**
 * 
 */

public class SortUtilEnd {

    public static int totalNum = 12;

    static int initNum[] = new int[totalNum];

    public static void main(String[] args) {
        for (int i = 0; i < totalNum; i++) {
            initNum[i] = (int) (Math.random() * 100);
        }

        printNum(initNum);
        System.out.println("++++++++++++++++++++++++++++");
        sortAlgorithm6(initNum);
        printNum(initNum);
    }

    // 冒泡排序
    public static void sortAlgorithm1(int initNum[]) {
        int temp = 0;
        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];
                    initNum[j] = initNum[j + 1];
                    initNum[j + 1] = temp;
                }
            }
        }

    }

    // 选择排序
    public static void sortAlgorithm2(int initNum[]) {
        int max = 0;
        int temp = 0;
        for (int i = initNum.length - 1; i >= 0; i--) {
            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;
        int k = 0;
        for (int i = 1; i < initNum.length; i++) {
            temp = initNum[i];
            k = i;
            while (k > 0 && initNum[k - 1] > temp) {// 依然会犯错误，要从前面的一个数字开始取出来比较
                initNum[k] = initNum[--k];
            }
            initNum[k] = temp;
        }

    }

    // 希尔排序,直接在插入排序的基础上加一个步长就可以了
    public static void sortAlgorithm4(int initNum[]) {
        int temp = 0;
        int k = 0;
        // 选择一个步长，在插入排序的基础上
        for (int j = initNum.length / 2; j > 0; j = j / 2) {

            for (int i = j; i < initNum.length; i += j) {
                temp = initNum[i];
                k = i;
                while (k > 0 && initNum[k - j] > temp) {// 依然会犯错误，要从前面的一个数字开始取出来比较
                    initNum[k] = initNum[k - j];
                    k = 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 start = left;
        int end = right;
        while(left<right){
            while(left<right&&initNum[right]>=temp){
                right--;
            }
            initNum[left]=initNum[right];
            while(left<right&&initNum[left]<=temp){
                left++;
            }
            initNum[right]=initNum[left];
        }
        initNum[left]=temp;//忘了一句，将最后的值赋值回去
        quickSort(initNum,start,left-1);
        quickSort(initNum,left+1,end);
        }
    }

    // 堆排序，重要的是那个辅助方法，将一个数字插入大顶堆中
    public static void sortAlgorithm6(int initNum[]) {
        int temp = 0;
        //生成大顶堆
        for(int i= initNum.length/2-1;i>=0;i--){
            insertHeap(initNum,i,initNum.length-1);
        }
        //将第一个数字放到堆后
        for(int j= initNum.length-1;j>=0;j--){
            temp = initNum[j];
            initNum[j]=initNum[0];
            initNum[0]= temp;
            insertHeap(initNum,0,j-1);
        }

    }
    /**
     * 将第一个点插入点到这个堆中
     * @param initNum 排序的对列
     * @param keyNode 要处理的起始点
     * @param lastNode 要处理的最后一个点
     */
    public static void insertHeap(int initNum[],int keyNode,int lastNode){
        if(keyNode>=lastNode){
            return;
        }
        int leftNode = keyNode*2+1;
        int rightNode = keyNode*2+2;
        int maxNode = keyNode;
        int temp = 0;
        if(leftNode<=lastNode&&initNum[leftNode]>initNum[maxNode]){
            maxNode = leftNode;
        }
        if(rightNode<=lastNode&&initNum[rightNode]>initNum[maxNode]){
            maxNode = rightNode;
        }
        if(maxNode!=keyNode){
            temp = initNum[keyNode];
            initNum[keyNode]=initNum[maxNode];
            initNum[maxNode]=temp;
        }
        insertHeap(initNum,leftNode,lastNode);
        insertHeap(initNum,rightNode,lastNode);     
    }

    // 归并排序,关键点是将两个有序数组合并成为一个有序数组
    public static void sortAlgorithm7(int initNum[]) {
        splitMethed(initNum, 0, initNum.length - 1);
    }

    public static void splitMethed(int initNum[], int left, int right) {
        int middle = (right + left) / 2;
        if (left < right) {
            splitMethed(initNum, left, middle);
            splitMethed(initNum, middle + 1, right);
            mergeMethed(initNum, left, middle, right);
        }

    }

    // 合并两个有序相邻的数组
    public static void mergeMethed(int initNum[], int left, int middle, int right) {

        int low1 = left;
        int low2 = middle + 1;
        int tempNums[] = new int[right - left + 1];
        int k = 0;

        while (low1 <= middle && low2 <= right) {
            if (initNum[low1] < initNum[low2]) {
                tempNums[k++] = initNum[low1++];
            } else {
                tempNums[k++] = initNum[low2++];
            }
        }
        while (low1 <= middle && low2 > right) {
            tempNums[k++] = initNum[low1++];
        }
        while (low1 > middle && low2 <= right) {
            tempNums[k++] = initNum[low2++];
        }

        for (int i = 0, j = left; i < tempNums.length; i++, j++) {
            initNum[j] = tempNums[i];
        }

    }

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

}