七大排序算法（Java实现）

七大排序算法

• 冒泡排序
• 选择排序
• 插入排序
• 希尔排序
• 快速排序
• 归并排序
• 堆排序

/**
 * 七大排序算法
 *
 * @author 王子龙
 * @date 2020-09-18 9:00
 */
public class Sort {
    private static int[] nums = {1,7,9,5,3,4,2,6,8,0};

    public static void main(String[] args) {
        // 冒泡排序
        int[] clone = nums.clone();
        bubbleSort(clone);
        System.out.println(Arrays.toString(clone));

        // 选择排序
        clone = nums.clone();
        selectSort(clone);
        System.out.println(Arrays.toString(clone));

        // 插入排序
        clone = nums.clone();
        insertSort(clone);
        System.out.println(Arrays.toString(clone));

        // 希尔排序
        clone = nums.clone();
        shellSort(clone);
        System.out.println(Arrays.toString(clone));

        // 快速排序
        clone = nums.clone();
        quickSortRec(clone);
        System.out.println(Arrays.toString(clone));

        // 归并排序
        clone = nums.clone();
        mergeSortRec(clone);
        System.out.println(Arrays.toString(clone));

        // 堆排序
        clone = nums.clone();
        heapSortRec(clone);
        System.out.println(Arrays.toString(clone));
    }

    /**
     * 交换数组
     *
     * @author 王子龙
     * @date 2020-9-18 14:49
     * @param array 数组
     * @param i 交换下标
     * @param j 交换下标
     * @return void
     **/
    private static void swap(int[] array, int i, int j) {
        array[i] ^= array[j];
        array[j] ^= array[i];
        array[i] ^= array[j];
    }

    /**
     * 冒泡排序
     *
     * @author 王子龙
     * @date 2020-9-18 9:03
     * @param array 需要排序的数组
     * @return void
     **/
    private static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    swap(array, j, j + 1);
                }
            }
        }
    }

    /**
     * 选择排序
     *
     * @author 王子龙
     * @date 2020-9-18 9:10
     * @param array 排序的数组
     * @return void
     **/
    private static void selectSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < array.length; j++) {
                if (array[min] > array[j]) {
                    min = j;
                }
            }
            if (min != i) {
                swap(array, min, i);
            }
        }
    }

    /**
     * 插入排序
     *
     * @author 王子龙
     * @date 2020-9-18 9:27
     * @param array 排序数组
     * @return void
     **/
    private static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int j;
            int tmp = array[i];
            for (j = i; j > 0 && tmp < array[j - 1]; j--) {
                    array[j] = array[j - 1];
            }
            array[j] = tmp;
        }
    }

    /**
     * 希尔排序（实际上是跨度大的插入排序）
     *
     * @author 王子龙
     * @date 2020-9-18 9:40
     * @param array 需要排序的数组
     * @return void
     **/
    private static void shellSort(int[] array) {
        int gap = 0;
        // 确定增量
        while (gap * 3 + 1 < array.length) {
            gap = gap * 3 + 1;
        }

        // 增量递减的排序
        while (gap > 0) {
            // 插入排序
            for (int i = gap; i < array.length; i++) {
                int j;
                int tmp = array[i];
                for (j = i; j >= gap && tmp < array[j - gap] ; j -= gap) {
                        array[j] = array[j - gap];
                }
                array[j] = tmp;
            }
            // 减少增量
            gap = (gap - 1) / 3;
        }
    }

    /**
     * 快速排序（递归）
     *
     * @author 王子龙
     * @date 2020-9-18 10:26
     * @param array 待排序的数组
     * @return void
     **/
    private static void quickSortRec(int[] array) {
        quickSortRecAux(array, 0, array.length - 1);
    }

    /**
     * 快速排序递归的辅助数组
     *
     * @author 王子龙
     * @date 2020-9-18 10:29
     * @param array 待排序数组
     * @param start 开始下标
     * @param end 结束下标
     * @return void
     **/
    private static void quickSortRecAux(int[] array, int start, int end) {
        if (start >= end) {
            return;
        }

        // 基准值
        int base = array[start], i = start, j = end;
        while (i < j) {
            // 找到右边比基准值小的数
            while (array[j] >= base && i < j) {
                j--;
            }
            // 把值移到左边去
            array[i] = array[j];
            // 找到左边比基准值大的数
            while (array[i] <= base && i < j) {
                i++;
            }
            // 把值移到右边去
            array[j] = array[i];
        }

        // 最后终点赋值
        array[i] = base;
        // 调用左侧
        quickSortRecAux(array,start ,i - 1);
        // 调用右侧
        quickSortRecAux(array,i + 1 ,end);
    }

    /**
     * 归并排序
     *
     * @author 王子龙
     * @date 2020-9-18 11:04
     * @param array 需要排序的数组
     * @return void
     **/
    private static void mergeSortRec(int[] array) {
        int[] result = new int[array.length];
        mergeSortRecAux(array,result ,0 ,array.length - 1 );
    }

    /**
     * 归并排序递归的辅助方法
     *
     * @author 王子龙
     * @date 2020-9-18 11:06
     * @param array 待排序的数组
     * @param result 结果数组
     * @param start 起点
     * @param end 终点
     * @return void
     **/
    private static void mergeSortRecAux(int[] array, int[] result, int start, int end) {
        if (start >= end) {
            return;
        }

        // 划分两侧进行归并排序然后合并
        int mid = (start + end) / 2;
        // 左侧
        mergeSortRecAux(array, result, start, mid);
        // 右侧
        mergeSortRecAux(array, result, mid + 1, end);
        // 合并
        mergeSortCombine(array, result, start, end);
    }

    /**
     * 归并排序递归的合并方法
     *
     * @author 王子龙
     * @date 2020-9-18 11:06
     * @param array 待排序的数组
     * @param result 结果数组
     * @param start 起点
     * @param end 终点
     * @return void
     **/
    private static void mergeSortCombine(int[] array, int[] result, int start, int end) {
        int mid = (start + end) / 2;
        int i = start, j = mid + 1, k = start;
        // 小的先赋值
        while (i <= mid && j <= end) {
            result[k++] = array[i] < array[j] ? array[i++] : array[j++];
        }

        // 如果前半段未赋完
        while (i <= mid) {
            result[k++] = array[i++];
        }

        // 如果后半段未赋完
        while (j <= end) {
            result[k++] = array[j++];
        }

        // 将结果数组赋值到原数组
        for (k = start; k <= end; k++) {
            array[k] = result[k];
        }
    }

    /**
     * 堆排序
     *
     * @author 王子龙
     * @date 2020-9-18 14:34
     * @param array 需要排序的数组
     * @return void
     **/
    private static void heapSortRec(int[] array) {
        // 首先从最后一个非叶子节点(n/2 - 1)开始构建大根堆
        for (int i = array.length / 2 - 1; i >= 0; i--) {
            heapSortRecAux(array, i, array.length);
        }
        swap(array, 0, array.length - 1);
        // 每次利用大根堆调整第k大的数到末尾
        for (int i = array.length - 2; i > 0 ; i--) {
            heapSortRecAux(array, 0, i + 1);
            swap(array, 0, i);
        }
    }

    /**
     * 以node节点为根构建大根堆
     *
     * @author 王子龙
     * @date 2020-9-18 14:39
     * @param array 待排序的数组
     * @param node 待调整的节点下标
     * @param length 目前还需排序的数组长度
     * @return void
     **/
    private static void heapSortRecAux(int[] array, int node, int length) {
        // 该节点无左孩子（即为叶子节点）
        int leftChild = 2 * node + 1;
        if (leftChild >= length) {
            return;
        }

        // 该节点只有左孩子（该节点为i,则2 * i + 1为左孩子下标，2 * i + 2为右孩子下标）
        int rightChild = 2 * node + 2, maxChild;
        if (rightChild >= length) {
            maxChild = leftChild;
        // 该节点有左右孩子
        } else {
            maxChild = array[leftChild] >= array[rightChild] ? leftChild : rightChild;
        }

        // 如果交换则还需要检查交换的子大根堆是否被破坏
        if (array[node] < array[maxChild]) {
            swap(array, node, maxChild);
            heapSortRecAux(array, maxChild, length);
        }
    }
}