Java实现十大排序（详细注释）

已于 2022-10-01 08:44:50 修改
阅读量264 收藏 1
点赞数
分类专栏： 数据结构习题 文章标签： java 排序算法
于 2022-10-01 08:38:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41829337/article/details/127131377
版权

目录

冒泡排序 - 递增
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 冒泡排序（递增排序）
     *
     * @param nums
     */
    private void bubbleSort_1(int[] nums) {
        int len = nums.length;
        boolean flag;
        for (int i = 0; i < len - 1; i++) {  // 进行性len-1趟排序
            flag = true;
            for (int j = 0; j < len - i - 1; j++) { // 遍历无序区
                if (nums[j] > nums[j + 1]) { // 将最大的元素移动到无序区末尾
                    swap(nums, j, j + 1);
                    flag = false;
                }
            }
            if (flag) { // 无序区中没有发生交换说明已经有序
                break;
            }
        }
    }

    /**
     * 冒泡排序 - 递增
     * 1. 思想
     * [无序区，有序区]，从无序区通过交换找出最大元素放到有序区前端
     * 2. 复杂度
     * （1）平均时间复杂度：O(n^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        bubbleSort_1(nums);
    }
冒泡排序 - 递减
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 冒泡排序（递减排序）
     *
     * @param nums
     */
    private void bubbleSort_2(int[] nums) {
        int len = nums.length;
        boolean flag;
        for (int i = 0; i < len - 1; i++) {  // 进行性len-1趟排序
            flag = true;
            for (int j = 0; j < len - i - 1; j++) { // 遍历无序区
                if (nums[j] < nums[j + 1]) { // 将最小的元素移动到无序区末尾
                    swap(nums, j, j + 1);
                    flag = false;
                }
            }
            if (flag) { // 无序区中没有发生交换说明已经有序
                break;
            }
        }
    }

    /**
     * 冒泡排序 - 递减
     * 1. 思想
     * [无序区，有序区]，从无序区通过交换找出最小元素放到有序区前端
     * 2. 复杂度
     * （1）平均时间复杂度：O(n^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        bubbleSort_2(nums);
    }
选择排序 - 递增
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 选择排序（递增排序）
     *
     * @param nums
     */
    private void selectSort_1(int[] nums) {
        int len = nums.length;
        for (int i = 0; i < len - 1; i++) { // 进行性len-1趟排序
            int min = i; // 初始为有序区末尾元素
            for (int j = i + 1; j < len; j++) { // 遍历无序区
                if (nums[j] < nums[min]) { // 找到[有序区末尾元素，无序区]中最小元素下标
                    min = j;
                }
            }
            if (i != min) { // i == min时也可以交换，不影响结果
                swap(nums, i, min); // 交换有序区末尾元素和[有序区末尾元素，无序区]中最小元素
            }
        }
    }

    /**
     * 选择排序 - 递增
     * 1. 思想
     * [有序区，无序区]，在无序区里找一个最小的元素跟在有序区的后面
     * 2. 复杂度
     * （1）平均时间复杂度：O(n^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：数组不稳定、链表稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        selectSort_1(nums);
    }
选择排序 - 递减
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 选择排序（递减排序）
     *
     * @param nums
     */
    private void selectSort_2(int[] nums) {
        int len = nums.length;
        for (int i = 0; i < len - 1; i++) { // 进行性len-1趟排序
            int max = i; // 初始为有序区末尾元素
            for (int j = i + 1; j < len; j++) { // 遍历无序区
                if (nums[j] > nums[max]) { // 找到[有序区末尾元素，无序区]中最大元素下标
                    max = j;
                }
            }
            if (i != max) { // i == min时也可以交换，不影响结果
                swap(nums, i, max); // 交换有序区末尾元素和[有序区末尾元素，无序区]中最大元素
            }
        }
    }

    /**
     * 选择排序 - 递减
     * 1. 思想
     * [有序区，无序区]，在无序区里找一个最大的元素跟在有序区的后面
     * 2. 复杂度
     * （1）平均时间复杂度：O(n^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：数组不稳定、链表稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        selectSort_2(nums);
    }
插入排序 - 递增
    /**
     * 插入排序（递增排序）
     * 针对有序序列在插入时采用移动法
     *
     * @param nums
     */
    private void insertSort_1(int[] nums) {
        int len = nums.length;
        for (int i = 1; i < len; i++) { // 有序区从前往后扩张
            int insert = nums[i]; // insert为无序区第一个元素
            for (int j = i - 1; j >= 0; j--) { // 从后往前遍历有序区
                if (insert < nums[j]) { // insert小于前一个元素
                    nums[j + 1] = nums[j]; // 将nums[j]后移一位覆盖nums[j + 1]
                    nums[j] = insert; // insert插入原来nums[j]的位置
                } else { // insert大于前一个的元素，insert保持原来位置即可
                    break;
                }
            }
        }
    }

    /**
     * 插入排序 - 递增
     * 1. 思想
     * [有序区，无序区]，把无序区的第一个元素插入到有序区的合适的位置
     * 2. 复杂度
     * （1）平均时间复杂度：O(n^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        insertSort_1(nums);
    }
插入排序 - 递减
    /**
     * 插入排序（递减排序）
     * 针对有序序列在插入时采用移动法
     *
     * @param nums
     */
    private void insertSort_2(int[] nums) {
        int len = nums.length;
        for (int i = 1; i < len; i++) { // 有序区从前往后扩张
            int insert = nums[i]; // insert为无序区第一个元素
            for (int j = i - 1; j >= 0; j--) { // 从后往前遍历有序区
                if (insert > nums[j]) { // insert大于前一个元素
                    nums[j + 1] = nums[j]; // 将nums[j]后移一位覆盖nums[j + 1]
                    nums[j] = insert; // insert插入原来nums[j]的位置
                } else { // insert小于前一个的元素，insert保持原来位置即可
                    break;
                }
            }
        }
    }

    /**
     * 插入排序 - 递减
     * 1. 思想
     * [有序区，无序区]，把无序区的第一个元素插入到有序区的合适的位置
     * 2. 复杂度
     * （1）平均时间复杂度：O(n^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        insertSort_2(nums);
    }
快速排序 - 递增
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 快速排序（递增排序）
     *
     * @param nums
     * @param left
     * @param right
     */
    private void quickSort_1(int[] nums, int left, int right) {
        if (left < right) {
            int pivot = left; // 简便起见，默认以第一个元素作为主元
            int index = left + 1; // index指向[小数]区间最后一个元素下标
            for (int i = index; i <= right; i++) {
                if (nums[i] < nums[pivot]) { // 比主元小的元素都交换至[小数]区间
                    swap(nums, index, i);
                    index++;
                }
            }
            swap(nums, index - 1, pivot); // 将主元和[小数]区间最后一位元素交换位置
            pivot = index - 1; // 主元下标
            quickSort_1(nums, left, pivot - 1); // 对[小数]区间进行快排
            quickSort_1(nums, pivot + 1, right); // 对[大数]区间进行快排
        }
    }

    /**
     * 快速排序 - 递增
     * 1. 思想
     * [小数，基准元素，大数]，在区间中随机挑选一个元素作基准，将小于基准的元素放在基准之前，
     * 大于基准的元素放在基准之后，再分别对小数区与大数区进行排序
     * 2. 复杂度
     * （1）平均时间复杂度：O(nlogn)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(logn)
     * （4）稳定性：不稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        quickSort_1(nums, 0, nums.length - 1);
    }
快速排序 - 递减
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 快速排序（递减排序）
     *
     * @param nums
     * @param left
     * @param right
     */
    private void quickSort_2(int[] nums, int left, int right) {
        if (left < right) {
            int pivot = left; // 简便起见，默认以第一个元素作为主元
            int index = left + 1; // index指向[大数]区间最后一个元素下标
            for (int i = index; i <= right; i++) {
                if (nums[i] > nums[pivot]) { // 比主元大的元素都交换至[大数]区间
                    swap(nums, index, i);
                    index++;
                }
            }
            swap(nums, index - 1, pivot); // 将主元和[大数]区间最后一位元素交换位置
            pivot = index - 1; // 主元下标
            quickSort_2(nums, left, pivot - 1); // 对[大数]区间进行快排
            quickSort_2(nums, pivot + 1, right); // 对[小数]区间进行快排
        }
    }

    /**
     * 快速排序 - 递减
     * 1. 思想
     * [大数，基准元素，小数]，在区间中随机挑选一个元素作基准，将大于基准的元素放在基准之前，
     * 小于基准的元素放在基准之后，再分别对大数区与小数区进行排序
     * 2. 复杂度
     * （1）平均时间复杂度：O(nlogn)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(logn)
     * （4）稳定性：不稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        quickSort_2(nums, 0, nums.length - 1);
    }
堆排序 - 最大堆
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 对nums数组在[low, high]范围进行向下调整
     * 时间复杂度：O(logn)
     *
     * @param nums
     * @param low
     * @param high
     */
    private void downAdjust_1(int[] nums, int low, int high) {
        int dad = low, son = dad * 2 + 1; // dad为欲调整节点下标，son为其左孩子下标
        while (son <= high) { // 存在孩子节点
            if (son + 1 <= high && nums[son + 1] > nums[son]) { // 右孩子存在且右孩子大于左孩子
                son++; // son指向右孩子下标
            }
            if (nums[son] > nums[dad]) { // 左右孩子中最大者比欲调整节点大
                swap(nums, son, dad); // 欲调整节点和左右孩子中最大者交换位置
                dad = son; // dad指向欲调整节点最新位置
                son = dad * 2 + 1; // son指向欲调整节点最新位置左孩子下标
            } else { // 左右孩子中最大者比欲调整节点小，调整结束
                break;
            }
        }
    }

    /**
     * 建最大堆
     * （1）完全二叉树叶子节点个数为len/2，因此数组下标在[0, len/2-1]范围内的节点都是非叶子节点
     * （2）故可以从len/2-1开始倒着枚举节点
     * 时间复杂度：O(n)
     *
     * @param nums
     * @param len
     */
    private void createMaxHeap(int[] nums, int len) {
        for (int i = len / 2 - 1; i >= 0; i--) { // 从后往前遍历非叶子节点
            downAdjust_1(nums, i, len - 1);
        }
    }

    /**
     * 堆排序 - 最大堆
     * 1. 思想
     * [最大堆，有序区]，从堆顶把根拿出来放在有序区之前，再恢复堆
     * 2. 复杂度
     * （1）平均时间复杂度：O(nlogn)
     * （2）最差时间复杂度：O(nlogn)
     * （3）空间复杂度：O(1)
     * （4）稳定性：不稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        int len = nums.length;
        createMaxHeap(nums, len); // 建最大堆
        for (int i = len - 1; i > 0; i--) { // 从后往前遍历，直到堆中只剩一个元素
            swap(nums, i, 0);  // 交换最大堆中最后一个元素nums[i]与堆顶nums[0]
            downAdjust_1(nums, 0, i - 1); // 堆中元素减1，调整堆顶
        }
    }
堆排序 - 最小堆
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 对nums数组在[low, high]范围进行向下调整
     * 时间复杂度：O(logn)
     *
     * @param nums
     * @param low
     * @param high
     */
    private void downAdjust_2(int[] nums, int low, int high) {
        int dad = low, son = dad * 2 + 1; // dad为欲调整节点下标，son为其左孩子下标
        while (son <= high) { // 存在孩子节点
            if (son + 1 <= high && nums[son + 1] < nums[son]) { // 右孩子存在且右孩子小于左孩子
                son++; // son指向右孩子下标
            }
            if (nums[son] < nums[dad]) { // 左右孩子中最小者比欲调整节点小
                swap(nums, son, dad); // 欲调整节点和左右孩子中最小者交换位置
                dad = son; // dad指向欲调整节点最新位置
                son = dad * 2 + 1; // son指向欲调整节点最新位置左孩子下标
            } else { // 左右孩子中最小者比欲调整节点大，调整结束
                break;
            }
        }
    }

    /**
     * 建最小堆
     * （1）完全二叉树叶子节点个数为len/2，因此数组下标在[0, len/2-1]范围内的节点都是非叶子节点
     * （2）故可以从len/2-1开始倒着枚举节点
     * 时间复杂度：O(n)
     *
     * @param nums
     * @param len
     */
    private void createMinHeap(int[] nums, int len) {
        for (int i = len / 2 - 1; i >= 0; i--) { // 从后往前遍历非叶子节点
            downAdjust_2(nums, i, len - 1);
        }
    }

    /**
     * 堆排序 - 最小堆
     * 1. 思想
     * [最小堆，有序区]，从堆顶把根拿出来放在有序区之前，再恢复堆
     * 2. 复杂度
     * （1）平均时间复杂度：O(nlogn)
     * （2）最差时间复杂度：O(nlogn)
     * （3）空间复杂度：O(1)
     * （4）稳定性：不稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        int len = nums.length;
        createMinHeap(nums, len); // 建最小堆
        for (int i = len - 1; i > 0; i--) { // 从后往前遍历，直到堆中只剩一个元素
            swap(nums, i, 0);  // 交换最小堆中最后一个元素nums[i]与堆顶nums[0]
            downAdjust_2(nums, 0, i - 1); // 堆中元素减1，调整堆顶
        }
    }
归并排序 - 递增
    /**
     * 将递增区间nums[l1, r1]与nums[l2, r2]合并为递增区间
     * l1 = left, r1 = mid, l2 = mid + 1, r2 = right
     *
     * @param nums
     * @param left
     * @param mid
     * @param right
     */
    private void merge_1(int[] nums, int left, int mid, int right) {
        int i = left, j = mid + 1, index = 0;   // i指向nums[l1]，j指向nums[l2]
        int[] temp = new int[right - left + 1]; // temp临时存放合并后的数组，index为其下标
        while (i <= mid && j <= right) { // 遍历nums[l1, r1]和nums[l2, r2]公共长度部分
            temp[index++] = nums[i] < nums[j] ? nums[i++] : nums[j++]; // 将较小的元素放前面
        }
        while (i <= mid) {   // 将nums[l1, r1]剩余元素加入temp
            temp[index++] = nums[i++];
        }
        while (j <= right) { // 将nums[l2, r2]剩余元素加入temp
            temp[index++] = nums[j++];
        }
        for (int num : temp) {
            nums[left++] = num; // 将合并后的序列temp赋值回nums
        }
    }

    /**
     * 归并排序（递增排序）
     */
    private void mergeSort_1(int[] nums, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2; // 取[left, right]中点
            mergeSort_1(nums, left, mid); // 左子区间归并排序
            mergeSort_1(nums, mid + 1, right); // 右子区间归并排序
            merge_1(nums, left, mid, right); // 将左子区间和右子区间合并
        }
    }

    /**
     * 归并排序 - 递增
     * 1. 思想
     * 归并排序的核心在于将两个有序序列合并为一个有序序列
     * 2. 复杂度
     * （1）平均时间复杂度：O(nlogn)
     * （2）最差时间复杂度：O(nlogn)
     * （3）空间复杂度：O(n)
     * （4）稳定性：稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        mergeSort_1(nums, 0, nums.length - 1);
    }
归并排序 - 递减
    /**
     * 将递减区间nums[l1, r1]与nums[l2, r2]合并为递减区间
     * l1 = left, r1 = mid, l2 = mid + 1, r2 = right
     *
     * @param nums
     * @param left
     * @param mid
     * @param right
     */
    private void merge_2(int[] nums, int left, int mid, int right) {
        int i = left, j = mid + 1, index = 0;   // i指向nums[l1]，j指向nums[l2]
        int[] temp = new int[right - left + 1]; // temp临时存放合并后的数组，index为其下标
        while (i <= mid && j <= right) { // 遍历nums[l1, r1]和nums[l2, r2]公共长度部分
            temp[index++] = nums[i] > nums[j] ? nums[i++] : nums[j++]; // 将较大的元素放前面
        }
        while (i <= mid) {   // 将nums[l1, r1]剩余元素加入temp
            temp[index++] = nums[i++];
        }
        while (j <= right) { // 将nums[l2, r2]剩余元素加入temp
            temp[index++] = nums[j++];
        }
        for (int num : temp) {
            nums[left++] = num; // 将合并后的序列temp赋值回nums
        }
    }

    /**
     * 归并排序（递减排序）
     */
    private void mergeSort_2(int[] nums, int left, int right) {
        if (left < right) {
            int mid = left + (right - left) / 2; // 取[left, right]中点
            mergeSort_2(nums, left, mid); // 左子区间归并排序
            mergeSort_2(nums, mid + 1, right); // 右子区间归并排序
            merge_2(nums, left, mid, right); // 将左子区间和右子区间合并
        }
    }

    /**
     * 归并排序 - 递减
     * 1. 思想
     * 归并排序的核心在于将两个有序序列合并为一个有序序列
     * 2. 复杂度
     * （1）平均时间复杂度：O(nlogn)
     * （2）最差时间复杂度：O(nlogn)
     * （3）空间复杂度：O(n)
     * （4）稳定性：稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        mergeSort_2(nums, 0, nums.length - 1);
    }
希尔排序 - 递增
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 希尔排序（递增排序）
     * （1）针对有序序列在插入时采用交换法
     * （2）选择增量gap=len/2，缩小增量继续以gap=gap/2的方式
     * （3）{n/2, (n/2)/2, ..., 1}，称为增量序列
     *
     * @param nums
     */
    private void shellSort_1(int[] nums) {
        int len = nums.length;
        for (int gap = len / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < len; i++) { // 有序区从前往后扩张
                for (int j = i - gap; j >= 0; j -= gap) { // 从后往前遍历有序区
                    if (nums[j + gap] < nums[j]) { // 欲插入元素小于前一位元素
                        swap(nums, j, j + gap); // 交换二者位置
                    }
                }
            }
        }
    }

    /**
     * 希尔排序 - 递增
     * 1. 思想
     * 每一轮按照事先决定的间隔进行插入排序，间隔会依次缩小，最后一次一定要是1
     * 2. 复杂度
     * （1）平均时间复杂度：O(n(logn)^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：不稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        shellSort_1(nums);
    }
希尔排序 - 递减
    /**
     * 交换数组中两个元素的位置
     *
     * @param nums
     * @param i
     * @param j
     */
    private void swap(int[] nums, int i, int j) {
        if (i != j) { // 两个相同的数^结果为0，开头加一个判断可以避免这种情况
            nums[i] ^= nums[j];
            nums[j] ^= nums[i];
            nums[i] ^= nums[j];
        }
    }

    /**
     * 希尔排序（递减排序）
     * （1）针对有序序列在插入时采用交换法
     * （2）选择增量gap=len/2，缩小增量继续以gap=gap/2的方式
     * （3）{n/2, (n/2)/2, ..., 1}，称为增量序列
     *
     * @param nums
     */
    private void shellSort_2(int[] nums) {
        int len = nums.length;
        for (int gap = len / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < len; i++) { // 有序区从前往后扩张
                for (int j = i - gap; j >= 0; j -= gap) { // 从后往前遍历有序区
                    if (nums[j + gap] > nums[j]) { // 欲插入元素大于前一位元素
                        swap(nums, j, j + gap); // 交换二者位置
                    }
                }
            }
        }
    }

    /**
     * 希尔排序 - 递减
     * 1. 思想
     * 每一轮按照事先决定的间隔进行插入排序，间隔会依次缩小，最后一次一定要是1
     * 2. 复杂度
     * （1）平均时间复杂度：O(n(logn)^2)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(1)
     * （4）稳定性：不稳定
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        shellSort_2(nums);
    }
计数排序 - 递增
    /**
     * 计数排序（递增排序）
     * 计数排序不是比较排序，排序的速度快于任何比较排序算法
     *
     * @param nums
     */
    private void countSort_1(int[] nums) {
        int max = nums[0], min = nums[0];
        for (int num : nums) { // 找到最大值和最小值
            if (num > max) {
                max = num;
            }
            if (num < min) {
                min = num;
            }
        }
        int[] count = new int[max - min + 1]; // 根据最大值和最小值确定计数范围
        for (int num : nums) { // 开始计数
            count[num - min]++;
        }
        int k = 0;
        for (int i = 0; i < count.length; i++) { // 从前往后遍历count数组，替换掉nums数组
            for (int j = 0; j < count[i]; j++) {
                nums[k++] = min + i;
            }
        }
    }

    /**
     * 计数排序 - 递增
     * 1. 思想
     * 在给定的一组序列中，先找出该序列中的最大值和最小值，从而确定需要开辟多大的辅助空间，
     * 每一个数在对应的辅助空间中都有唯一的下标
     * 2. 复杂度
     * （1）平均时间复杂度：O(n+m)
     * （2）最差时间复杂度：O(n+m)
     * （3）空间复杂度：O(m)
     * （4）稳定性：稳定
     * m：代表计数范围
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        countSort_1(nums);
    }
计数排序 - 递减
    /**
     * 计数排序（递减排序）
     * 计数排序不是比较排序，排序的速度快于任何比较排序算法
     *
     * @param nums
     */
    private void countSort_2(int[] nums) {
        int max = nums[0], min = nums[0];
        for (int num : nums) { // 找到最大值和最小值
            if (num > max) {
                max = num;
            }
            if (num < min) {
                min = num;
            }
        }
        int[] count = new int[max - min + 1]; // 根据最大值和最小值确定计数范围
        for (int num : nums) { // 开始计数
            count[num - min]++;
        }
        int k = 0;
        for (int i = count.length - 1; i >= 0; i--) { // 从后往前遍历count数组，替换掉nums数组
            for (int j = 0; j < count[i]; j++) {
                nums[k++] = min + i;
            }
        }
    }

    /**
     * 计数排序 - 递减
     * 1. 思想
     * 在给定的一组序列中，先找出该序列中的最大值和最小值，从而确定需要开辟多大的辅助空间，
     * 每一个数在对应的辅助空间中都有唯一的下标
     * 2. 复杂度
     * （1）平均时间复杂度：O(n+m)
     * （2）最差时间复杂度：O(n+m)
     * （3）空间复杂度：O(m)
     * （4）稳定性：稳定
     * m：代表计数范围
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
        countSort_2(nums);
    }
桶排序 - 递增
    /**
     * 桶排序（递增排序）
     *
     * @param nums
     */
    private void bucketSort_1(int[] nums) {
        int len = nums.length;
        int max = nums[0], min = nums[0];
        for (int num : nums) { // 找到最大值和最小值
            if (num > max) {
                max = num;
            }
            if (num < min) {
                min = num;
            }
        }
        int gap = (max - min) / len + 1; // 确定桶的跨度大小
        int bucketNum = (max - min) / gap + 1; // 确定桶的个数
        List<List<Integer>> bucketList = new ArrayList<>(); // 创建一组桶
        for (int i = 0; i < bucketNum; i++) { // 初始化每个桶
            bucketList.add(new LinkedList<>());
        }
        for (int i = 0; i < nums.length; i++) { // 遍历数组，将数据放入对应桶中
            bucketList.get((nums[i] - min) / gap).add(nums[i]);
        }
        for (int i = 0; i < bucketList.size(); i++) { // 对每个桶内部从小到大进行排序
            Collections.sort(bucketList.get(i)); // 底层采用了归并排序的优化版本
        }
        int k = 0;
        for (int i = 0; i < bucketNum; i++) { // 把每个桶排序好的数据进行合并汇总放回原数组
            for (Integer num : bucketList.get(i)) {
                nums[k++] = num;
            }
        }
    }

    /**
     * 桶排序 - 递增
     * 1. 思想
     * 将最大值和最小值之间的元素进行瓜分，设定某个桶的容量，然后再定义每个桶的跨度，然后根据元素的大小范围，
     * 将他们放入各自的桶中，再对每个桶进行排序，最后按顺序输出所有桶中元素
     * 2. 复杂度
     * （1）平均时间复杂度：O(n+m)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(n+m)
     * （4）稳定性：稳定
     * m：代表计数范围
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
       bucketSort_1(nums);
    }
桶排序 - 递减
    /**
     * 桶排序（递减排序）
     *
     * @param nums
     */
    private void bucketSort_2(int[] nums) {
        int len = nums.length;
        int max = nums[0], min = nums[0];
        for (int num : nums) { // 找到最大值和最小值
            if (num > max) {
                max = num;
            }
            if (num < min) {
                min = num;
            }
        }
        int gap = (max - min) / len + 1; // 确定桶的跨度大小
        int bucketNum = (max - min) / gap + 1; // 确定桶的个数
        List<List<Integer>> bucketList = new ArrayList<>(); // 创建一组桶
        for (int i = 0; i < bucketNum; i++) { // 初始化每个桶
            bucketList.add(new LinkedList<>());
        }
        for (int i = 0; i < nums.length; i++) { // 遍历数组，将数据放入对应桶中
            bucketList.get((nums[i] - min) / gap).add(nums[i]);
        }
        for (int i = 0; i < bucketList.size(); i++) { // 对每个桶内部从大到小进行排序
            Collections.sort(bucketList.get(i), Collections.reverseOrder()); // 底层采用了归并排序的优化版本
        }
        int k = 0;
        for (int i = bucketNum - 1; i >= 0; i--) { // 把每个桶排序好的数据进行合并汇总放回原数组
            for (Integer num : bucketList.get(i)) {
                nums[k++] = num;
            }
        }
    }

    /**
     * 桶排序 - 递减
     * 1. 思想
     * 将最大值和最小值之间的元素进行瓜分，设定某个桶的容量，然后再定义每个桶的跨度，然后根据元素的大小范围，
     * 将他们放入各自的桶中，再对每个桶进行排序，最后按顺序输出所有桶中元素
     * 2. 复杂度
     * （1）平均时间复杂度：O(n+m)
     * （2）最差时间复杂度：O(n^2)
     * （3）空间复杂度：O(n+m)
     * （4）稳定性：稳定
     * m：代表计数范围
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
       bucketSort_2(nums);
    }
基数排序 - 递增
    /**
     * 基数排序（递增排序）
     * （1）所有数字都是由0~9组成，因此需要10个桶来排序
     * （2）暂时无法处理负数
     *
     * @param nums
     */
    private void radixSort_1(int[] nums) {
        int len = nums.length;
        int max = nums[0];
        for (int num : nums) { // 找到最大数
            if (num > max) {
                max = num;
            }
        }
        int digit = 0;
        while (max != 0) { // 获取最大数的位数
            max /= 10;
            digit++;
        }
        int bucketNum = 10; // 创建10个桶
        List<List<Integer>> bucketList = new ArrayList<>();
        for (int i = 0; i < bucketNum; i++) { // 初始化每个桶
            bucketList.add(new LinkedList<>());
        }
        for (int i = 0; i < digit; i++) { // 按最低位优先依次对各关键字进行分配和收集
            for (int j = 0; j < len; j++) { // 第i趟分配
                int radix = (int) (nums[j] / Math.pow(10, i)) % 10; // 获取当前数字第i位的数
                bucketList.get(radix).add(nums[j]); // 放进对应的桶里
            }
            int k = 0;
            for (List<Integer> bucket : bucketList) { // 第i趟收集，按第i位从小到大的顺序将num排序
                for (Integer num : bucket) {
                    nums[k++] = num;
                }
                bucket.clear(); // 将每个桶都清空，供下一次分配和收集使用
            }
        }
    }

    /**
     * 基数排序 - 递增
     * 1. 思想
     * 按位数从低到高分配到桶中，有多少位分配多少次，分配完成后，从低位到高位依次取出
     * 2. 复杂度
     * （1）平均时间复杂度：O(n*k)
     * （2）最差时间复杂度：O(n*k)
     * （3）空间复杂度：O(n+k)
     * （4）稳定性：稳定
     * k：代表数值中的"数位"个数
     * 3. 优缺点
     * （1）优点：在数字位数相差不大的情况下具有较高效率，如[345, 652, 984, 439]，都是三位数，需要分配+收集三次
     * （2）缺点：在数字位数差距非常大时，效率低下，如[1，999999999999999]，需要分配+收集m次，m为较大数字的位数
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
       radixSort_1(nums);
    }
基数排序 - 递减
    /**
     * 基数排序（递减排序）
     * （1）所有数字都是由0~9组成，因此需要10个桶来排序
     * （2）暂时无法处理负数
     *
     * @param nums
     */
    private void radixSort_2(int[] nums) {
        int len = nums.length;
        int max = nums[0];
        for (int num : nums) { // 找到最大数
            if (num > max) {
                max = num;
            }
        }
        int digit = 0;
        while (max != 0) { // 获取最大数的位数
            max /= 10;
            digit++;
        }
        int bucketNum = 10; // 创建10个桶
        List<List<Integer>> bucketList = new ArrayList<>();
        for (int i = 0; i < bucketNum; i++) { // 初始化每个桶
            bucketList.add(new LinkedList<>());
        }
        for (int i = 0; i < digit; i++) { // 按最低位优先依次对各关键字进行分配和收集
            for (int j = 0; j < len; j++) { // 第i趟分配
                int radix = (int) (nums[j] / Math.pow(10, i)) % 10; // 获取当前数字第i位的数
                bucketList.get(radix).add(nums[j]); // 放进对应的桶里
            }
            int k = 0;
            for (int j = bucketNum - 1; j >= 0; j--) { // 第i趟收集，按第i位从大到小的顺序将num排序
                List<Integer> bucket = bucketList.get(j);
                for (Integer num : bucket) {
                    nums[k++] = num;
                }
                bucket.clear(); // 将每个桶都清空，供下一次分配和收集使用
            }
        }
    }

    /**
     * 基数排序 - 递减
     * 1. 思想
     * 按位数从低到高分配到桶中，有多少位分配多少次，分配完成后，从低位到高位依次取出
     * 2. 复杂度
     * （1）平均时间复杂度：O(n*k)
     * （2）最差时间复杂度：O(n*k)
     * （3）空间复杂度：O(n+k)
     * （4）稳定性：稳定
     * k：代表数值中的"数位"个数
     * 3. 优缺点
     * （1）优点：在数字位数相差不大的情况下具有较高效率，如[345, 652, 984, 439]，都是三位数，需要分配+收集三次
     * （2）缺点：在数字位数差距非常大时，效率低下，如[1，999999999999999]，需要分配+收集m次，m为较大数字的位数
     *
     * @param nums
     * @param k
     * @return
     */
    public void sortTest(int[] nums) {
       radixSort_2(nums);
    }
happy life 2022
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java 数据结构】十大排序 (动图解析)
书生-w的博客
04-24 1万+
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
详解Java常用排序算法（10种，含演示动画）
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
06-30 2万+
Java常用的排序算法有以下几种： 1. 冒泡排序；2. 选择排序；3. 插入排序；4. 希尔排序；5. 归并排序；6. 快速排序；7. 堆排序；8. 计数排序；9. 桶排序；10. 基数排序。 这些排序算法都有各自的优缺点，应根据具体情况选择适合的算法。
十大排序算法（Java实现）
ji_meng的博客
06-27 2774
1.冒泡排序 2.快速排序
Java实现十大排序算法
qq_56517253的博客
12-27 1000
马士兵教育十大排序算法讲解和记忆
Java十种经典排序算法详解与应用
最新发布
weixin_69595694的博客
01-06 1190
Java中提供了多种排序算法实现，涵盖了简单排序和高级排序技术。这些算法包括但不限于冒泡排序（Bubble Sort）、选择排序（Selection Sort）、插入排序（Insertion Sort）、希尔排序（Shell Sort）、归并排序（Merge Sort）、快速排序（Quick Sort）、堆排序（Heap Sort）、计数排序（Counting Sort）、桶排序（Bucket Sort）以及基数排序（Radix Sort）。每种排序算法在时间复杂度、空间复杂度、稳定性等方面各有优劣。
十种排序的Java代码实现
02-06
十种排序的Java代码实现,其中包含注释
java代码实现的排序算法
07-04
java代码实现的排序算法（冒泡，快速，简单选择，堆排，直接插入，希尔，归并），代码本身的注释不多，主要注释的还是当前排序算法的一些特点，比如时间复杂度，空间复杂度，一趟排序后数列的特点。适合了解算法性质...
java实现数据结构常见排序算法及详解
11-08
详细讲述了8中常见算法的原理及思想，并用JAVA进行了实现，代码中有详细的注释，解释了算法的实现逻辑和一些小技巧。
java实现数组冒泡排序
09-23
java实现数组从小到大排序，输出为数组。可以直接拿来用，注释清楚，可读性强，适用于基础练习，课堂作业等
Java冒泡排序算法实现
03-20
Java冒泡排序算法实现，内附源码和详细注释
十大常用排序算法（java实现）
11-01
十大常用排序算法（java实现）,冒泡排序，简单选择排序等
java实现的八种基本排序算法（有注释）
06-28
自己收集的一些小算法代码，这是基本的数据结构的八种排序算法，里面有注释，用的是java代码实现的
十大经典排序算法（Java版本）
m0_64354070的博客
12-08 862
排序算法的重要性不言而喻，为了加深对这十种算法的理解，固写此文。 目录 1、冒泡排序（Bubble Sort） 2、选择排序（Selection Sort） 3、插入排序（Insertion Sort） 4、希尔排序（Shell Sort） 5、归并排序（Merge Sort） 6、快速排序（Quick Sort） 7、堆排序（Heap Sort） 8、计数排序（Counting Sort） 9、桶排序（Bucket Sort） 10、基数排序（Radix Sort） 首先可用如下表来
十大排序（Java版本）
weixin_71020872的博客
01-18 3403
排序分为比较排序和非比较排序两种，常见的排序为比较排序，共有七类：直接插入排序、希尔排序、选择排序、冒泡排序、堆排序、快速排序以及归并排序。另有三种非基于比较类的排序：计数排序、基数排序和桶排序。
十大常见排序算法（java编写）
c_study__c的博客
01-26 1343
十大排序算法（java编写）排序算法基本思路，相关时间复杂度和空间复杂度以及稳定性
java十大排序法_Java 十大排序算法
weixin_35282584的博客
02-27 237
目录：1、冒泡排序(Bubble Sort)2、选择排序(Selection Sort)3、插入排序(Insertion Sort)4、希尔排序(Shell Sort)5、归并排序(Merge Sort)6、快速排序(Quick Sort)7、堆排序(Heap Sort)8、计数排序(Counting Sort)9、桶排序(Bucket Sort)10、基数排序(Radix Sort)1、冒泡排序...
java 十大经典排序算法
殇~浅心
01-20 714
十大排序算法可以说是每个程序员都必须得掌握的了，花了一天的时间把代码实现且整理了一下，为了方便大家学习，我把它整理成一篇文章，每种算法会有简单的算法思想描述，为了方便大家理解，我还找来了动图演示；这还不够，我还附上了对应的优质文章，看完不懂你来砍我，如果不想砍我就给我来个好看。术语铺垫有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这里先简单解释一下：1、稳定排序：如果 a 原...
java 实现快速排序，加上详细中文代码注释
02-08
以下是 Java 实现快速排序的代码，带有详细的中文注释： ``` public class QuickSort { public static void main(String[] args) { int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1}; quickSort(arr, 0, arr.length - 1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值