【Java】排序算法

    /**
     * 堆排序 不稳定
     * 实现思路：
     * 按照顺序计数法（任何一个节点的左节点的下标为2i+1，右节点为2i+2），将其构造为大顶堆。
     * 将顶与最后一位数字交换，最大的数字来到数组的最右端
     * 再构造大顶堆，再交换顶与倒数第二位数字，令倒数第二位的位置盛放倒数第二大的数字
     *
     * @return
     */
    public static int[] heapSort(int[] arr) {
        if (arr.length == 0) return arr;

        for (int lastIndex = arr.length - 1; lastIndex > 0; lastIndex--) {
            adjustHeap(arr, lastIndex);
            swap(arr, 0, lastIndex);
        }
        return arr;
    }

    private static void adjustHeap(int[] arr, int lastIndex) {
        for (int k = (lastIndex - 1) / 2; k >= 0; k--) {//k为最后一个非叶子节点
            if (k * 2 + 1 == lastIndex) { //说明最后一个非叶子节点有1个儿子
                if (arr[k * 2 + 1] > arr[k]) {//如果儿子大于父亲,则交换
                    swap(arr, k, k * 2 + 1);
                    continue;
                }
            } else {
                //判断子节点中是否有比父亲大的
                if (arr[k] < Math.max(arr[2 * k + 1], arr[2 * k + 2])) {
                    //有的话，将最大的节点和父节点交换
                    swap(arr, k, arr[k * 2 + 1] > arr[k * 2 + 2] ? (k * 2 + 1) : (k * 2 + 2));
                }
            }
            //没有的话就空执行
        }
    }

    /**
     * 冒泡排序 稳定
     *
     * @param arr 输入的数组
     * @return 外侧每一轮的任务是，把最大的数字放在右边，之后是把第二大的数字放在右数第二个。
     */
    public static int[] maopaoSort(int[] arr) {
        if (arr.length == 0) return arr;

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                }
            }
        }
        return arr;
    }

    /**
     * 选择排序 稳定
     * 工作原理：
     * 在序列中找到最小元素，和最左端元素交换位置，之后左指针++，
     * 剩余未排序元素中继续寻找最小元素，
     *
     * @param arr
     * @return
     */
    public static int[] selectSort(int[] arr) {
        if (arr.length == 0) return arr;

        for (int i = 0; i < arr.length; i++) {
            int min = arr[i];//初始化最小值
            int minIndex = i;//初始化最小值的index

            for (int j = i; j < arr.length; j++) {
                if (arr[j] < min) {//获取每一轮的最小值+下标
                    minIndex = j;
                    min = arr[j];
                }
            }
            //把每一轮的最小元素放在最终位置上
            swap(arr, i, minIndex);
        }
        return arr;
    }

    /**
     * 插入排序 稳定
     * 设定一个左指针i，默认为1，不是0！，取出这个i对应的元素
     * 之后以指针i为右边界，向左遍历，将左边的位填充到本位，
     * 之后i--，如果提取出来的元素比前面的小，那么停止
     * 此时将我们之前提取出来的初始元素，放在现在的位置。
     *
     * @param arr
     * @return
     */
    public static int[] insertSort(int[] arr) {
        if (arr.length == 0) return null;
        for (int i = 1; i < arr.length; i++) {
            int theOne = arr[i];
            int j = i;
            while (j >= 0 && arr[j] > theOne) {
                arr[j] = arr[j - 1];
                j--;
            }
            arr[j] = theOne;//把temp放到空位上
        }
        return arr;
    }
    /**
     * 快速排序
     * @param
     * @return 实现思路：
     * 首先设定一个基准元素
     * 再设立左哨兵i和右哨兵j
     * j从右往左获取第一个比基准元素小的值，j记录其下标
     * i从左往右记录第一个比基准元素大的值，记录下标
     * 通过下标交换这两个元素
     * 继续以上操作，直到i==j
     * 就将基准元素的下标和i（说成j也一样，因为都相等了嘛）互换位置，从而确定了第一个基准元素的位置。
     * 记这个位置为分界线，左序列和右序列分别迭代快速排序的方法。
     */

    public static int[] quickSort(int[] arr) {
        if (arr.length == 0) return null;
        quick(arr, 0, arr.length - 1);
        return arr;
    }

    private static void quick(int[] input, int begin, int end) {
        if (begin >= end) return;
        //设置左右哨兵
        int i = begin;
        int j = end;
        int standard = input[begin];//设置基准值
        while (j > i) {
            //右哨兵先往回遍历，找到第一个小于基准值的元素，记录下标
            while (input[j] >= standard && j > i) {
                j--;
            }
            //左哨兵往前遍历，找到第一个大于基准值的元素，记录下标
            while (input[i] <= standard && j > i) {
                i++;
            }
            if (i < j) {//记得在判断一下条件，防止i、j交错而过
                swap(input, i, j);
            }
        }
        //当i == j时，跳出循环，和基准元素互换位置，基准元素的最终位置已经确定，完成一轮排序。
        swap(input, i, begin);
        //进行递归（递归是自己调用自己，迭代是在循环中更新值）
        quick(input, 0, i - 1);
        quick(input, i + 1, end);
    }

    /**
     * 归并排序
     *
     * @param array 输入数组
     * @return
     */
    public static int[] guibingSort(int[] array) {


        return array;
    }

    //###################### tool methods ###################

    public static void printArray(int[] input) {
        for (int i : input) {
            System.out.print(i + ",");
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }