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

package com.luojie;

/**
 * 
 * @author Brandon 练习排序算法
 */

public class SortUtil {

    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("++++++++++++++++++++++++++++");
        sortAlgorithm7(initNum);
        printNum(initNum);
    }

    // 冒泡排序
    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];
                    initNum[j] = initNum[j + 1];
                    initNum[j + 1] = temp;
                }
            }
        }
    }

    // 选择排序
    public static void sortAlgorithm2(int initNum[]) {
        int max = 0;
        int temp = -1;
        for (int i = initNum.length - 1; i >= 0; i--) {
            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;
        int j = 0;

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

    }

    // 希尔排序,直接在插入排序的基础上加一个步长就可以了
    public static void sortAlgorithm4(int initNum[]) {
        int temp = 0;
        int j = 0;
        for (int g = initNum.length / 2; g > 0; g = g / 2) {
            for (int i = g; i < initNum.length; i += g) {
                temp = initNum[i];
                j = i;
                while (j > 0 && initNum[j - g] > temp) {
                    initNum[j] = initNum[j - g];
                    j -= g;
                }
                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) {// 注意中间的那个等号，不然会产生死循环最后走不出来
                    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;
        // 第一步：生成堆
        for (int i = initNum.length / 2 - 1; i >= 0; i--) {
            insertMethed(initNum, i, initNum.length - 1);
        }
        for (int j = initNum.length - 1; j >= 0; j--) {
            temp = initNum[j];
            initNum[j] = initNum[0];
            initNum[0] = temp;
            insertMethed(initNum, 0, j);
        }
        // 第二步：循环交换，在循环中将其新加入堆数字进行排序

    }

    // 辅助方法
    public static void insertMethed(int initNum[], int startNode, int endNode) {
        if (startNode < endNode) {
            int leftNode = startNode * 2 + 1;
            int rightNode = startNode * 2 + 2;
            int maxNode = startNode;
            int temp = 0;
            if (leftNode < endNode && initNum[leftNode] > initNum[maxNode]) {
                maxNode = leftNode;
            }
            if (rightNode < endNode && initNum[rightNode] > initNum[maxNode]) {
                maxNode = rightNode;
            }
            if (maxNode != startNode) {
                temp = initNum[maxNode];
                initNum[maxNode] = initNum[startNode];
                initNum[startNode] = temp;
            }
            insertMethed(initNum, leftNode, endNode);
            insertMethed(initNum, rightNode, endNode);
        }
    }
    // 归并排序,关键点是将两个有序数组合并成为一个有序数组
    public static void sortAlgorithm7(int intNum[]) {
        recursionMethed(initNum, 0, initNum.length - 1);
    }

    // 递归
    public static void recursionMethed(int initNum[], int left, int right) {

        int temp = (left + right) / 2;
        if (left < right) {
            recursionMethed(initNum, left, temp);
            recursionMethed(initNum, temp + 1, right);
            mergeMethed(initNum, left, temp, right);
        }
    }

    // 合并方法,只适合相邻堆两个有序堆数组
    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 printNum(int initNum[]) {
        for (int i = 0; i < initNum.length; i++) {
            System.out.println(initNum[i]);
        }
    }

}