排序算法详解（Java实现 + 动画演示）

最新推荐文章于 2021-08-06 11:12:51 发布

置顶 6铭记6

最新推荐文章于 2021-08-06 11:12:51 发布

阅读量1.9k

点赞数 5

分类专栏：算法面试文章标签：算法排序算法复杂度分析动画演示面试

本文链接：https://blog.csdn.net/jzycloud/article/details/115675875

版权

算法同时被 2 个专栏收录

2 篇文章 1 订阅

订阅专栏

面试

1 篇文章 0 订阅

订阅专栏

引言

本篇文章给出了十大经典排序算法和一些奇特、有趣的排序算法的实现原理解析，附有时间复杂度、空间复杂度分析和相应的Java实现代码，并给出了动画演示

如需浏览，请详见目录，即可快速定位到所需要的内容。之后将会持续修缮文章，如需及时收到最新内容，记得关注、收藏一下┗|｀O′|┛ 嗷~~

一、排序算法概述

排序的定义

排序，是将一批无序的记录（数据）重新排列成按关键字有序的记录序列的过程；其目的是将一组“无序”的数据组调整为“有序”的数据组

术语说明

稳定：排序前a在b的前面，且a = b（该“=”的含义是在所定义的排序规则下是相等，包括但不仅限于数值上的相等），排序后a依旧在b的前面（相对位置保持不变）
不稳定：排序前a在b的前面，且a = b（该“=”的含义是在所定义的排序规则下是相等，包括但不仅限于数值上的相等），排序后a可能在b的前面，也可能在b的后面（相对位置发生变化）
内部排序：在排序过程中，所有元素调到内存中进行的排序
外部排序：在排序过程中，待排序记录的数量很大，以致于内存不能一次容纳全部记录，故而在排序过程中需要对外存进行数据的临时存放、访问的排序
时间复杂度：描述了算法执行时间随输入规模增长而增长的量级
空间复杂度：描述了算法执行过程中临时占用存储空间大小的量度

排序算法分类及对比

在这里插入图片描述

符号解释

n：数据规模
k：桶的个数
In-place：仅占用常数级内存，不额外占用与数据规模有关内存空间
Out-place：需额外占用与数据规模有关的内存空间

比较排序和非比较排序的区别

常见的冒泡排序、快速排序、归并排序、堆排序等都属于比较排序，而桶排序、计数排序、基数排序等则属于非比较排序

比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序；可以说，比较排序适用于一切需要排序的情况

非比较排序的优势是，算法时间复杂度仅为O(n)，即只要确定每个元素之前的已有的元素个数即可，排序仅需一次遍历即可

虽然非比较排序的时间复杂度低，但是由于非比较排序需要占用额外空间来存唯一储确定的位置，而且对于的数据规模和数据的分布有一定的要求，所以普适性不如比较排序；实际使用中，需要根据具体的待排序数据组的情况来抉择！

二、十大经典排序算法

1、直接选择排序

选择排序（Select Sort）是一种简单且直观的排序算法，通常是大多数人在一般情况下可以直接想到的排序方法，同时也是表现最稳定的排序算法之一，无论什么数据组进去都是O( )的时间复杂度；如果采用直接选择排序进行排序的话，数据规模理应越小越好。其优点是不占用额外的内存空间并且利于理解！

其实现原理直观来讲，首先在还未排序的序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序的元素中继续寻找最小（大）元素，将此次循环找出的最小（大）元素放到已排序序列的末尾。循环往复，直到所有元素均排序完毕

算法描述

n个记录的直接选择排序可经过n - 1趟直接选择排序得到有序结果

初始状态：无序区为R[1, …, n]，有序区为空
第i趟排序(i = 1, 2, 3, …, n - 1)开始时，当前有序区和无序区分别为R[1, …, i - 1]和R(1, …, n）；该趟排序从当前无序区中选出关键字最小（大）的记录 R[k]，将它与无序区的第1个记录R交换，使R[1, …, i]和R[i + 1, …, n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区
n - 1趟结束，数据组有序化

动画演示
在这里插入图片描述
代码实现

/**
 * 直接选择排序
 *
 * @param nums 待排序的数据组
 */
public static void selectSort(int[] nums){
    int length = nums.length;
    int minIndex;
    int temp;
    for (int i = 0; i < length; i++) {
        minIndex = i;
        for (int j = i + 1; j < length; j++) {
            if (nums[j] < nums[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            temp = nums[i];
            nums[i] = nums[minIndex];
            nums[minIndex] = temp;
        }
    }
}

2、堆排序

要特别注意的是，在实际的面试中，经常会要求自行编写代码来实现堆排序（不能使用高级语言中已经封装并实现了堆排序的函数方法或对象），故而要着重理解，一气呵成、手撕堆排序啊@.@

堆的定义如下：n个元素的序列{k1, k2, …, kn}当且仅当满足一下条件时，称之为堆；可以将堆看做是一个完全二叉树，并且每个结点的值都大于等于其左右孩子结点的值，称为大顶堆，或者每个结点的值都小于等于其左右孩子结点的值，称为小顶堆

堆排序（Heap Sort）是利用堆进行排序的方法。其基本思想为：将待排序列构造成一个大顶堆（或小顶堆），整个序列的最大值（或最小值）就是堆顶的根结点，将根节点的值和堆数组的末尾元素交换，此时末尾元素就是最大值（或最小值），然后将剩余的n-1个序列重新构造成一个堆，这样就会得到n个元素中的次大值（或次小值），如此反复执行，最终得到一个有序序列
在这里插入图片描述
算法描述

将初始待排序关键字序列(R1, R2, …, Rn)构建成大顶堆，此堆为初始的无序区
将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1, R2 , …, Rn-1)和新的有序区(Rn),且满足R[1, 2, …, n - 1] <= R[n]
由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1, R2, …, Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1, R2, …, Rn-2)和新的有序区(Rn-1, Rn)。不断重复步骤3，直到有序区的元素个数为n - 1，则整个排序过程完成

动画演示
在这里插入图片描述
代码实现

/**
 * 堆排序
 *
 * @param nums 待排序的数据组
 */
public static void heapSort(int[] nums){
    int length = nums.length;
    // 初始化堆，构造一个最大堆
    for(int i = (length / 2 - 1); i >= 0; i--){
        heapAdjust(nums, i, length);
    }
    // 将堆顶的元素和最后一个元素交换，并重新调整堆
    for(int i = length - 1; i > 0; i--){
        int temp = nums[i];
        nums[i] = nums[0];
        nums[0] = temp;
        heapAdjust(nums, 0, i);
    }
}

/**
 * 堆调整
 *
 * @param nums 待调整的数据组
 * @param index 当前结点下标
 * @param length 需调整的数据组长度
 */
public static void heapAdjust(int[] nums, int index, int length){
    // 保存当前结点的下标
    int flag = index;
    // 当前节点左子节点的下标
    int left = 2 * index;
    // 当前节点右子节点的下标
    int right = 2 * index + 1;
    if (length > left && nums[flag] < nums[left]) {
        flag = left;
    }
    if (length > right && nums[flag] < nums[right]) {
        flag = right;
    }
    // 若此节点比其左右孩子的值小，就将其和最大值交换，并调整堆
    if (flag != index) {
        int temp = nums[index];
        nums[index] = nums[flag];
        nums[flag] = temp;
        heapAdjust(nums, flag, length);
    }
}

3、直接插入排序

插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。其工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用In-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间

算法描述

从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后，重复步骤2~5

动画演示
在这里插入图片描述
代码实现

/**
 * 直接插入排序
 *
 * @param nums 待排序的数据组
 */
public static void insertSort(int[] nums){
    int length = nums.length;
    int current;
    int tempIndex;
    for (int i = 1; i < length; i++) {
        current = nums[i];
        tempIndex = i - 1;
        while (tempIndex >= 0 && current < nums[tempIndex]) {
            nums[tempIndex + 1] = nums[tempIndex];
            tempIndex--;
        }
        nums[tempIndex + 1] = current;
    }
}

4、希尔排序

希尔排序（Shell Sort）是希尔（Donald Shell）于1959年提出的一种排序算法；希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，它与插入排序的不同之处在于，它会优先比较距离较远的元素，故而也称为缩小增量排序，同时该排序算法是冲破时间复杂度O( ）的第一批算法之一

希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

算法描述

选择增量gap = length / 2，缩小增量继续以gap = gap / 2的方式，这种增量选择可以用一个序列来表示，{n / 2, (n / 2) / 2, …, 1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，当前选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的！

选择一个增量序列t1，t2，…，tk，其中ti > tj，tk = 1
按增量序列个数k，对序列进行k 趟排序
每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度

动画演示
在这里插入图片描述

代码实现

/**
 * 希尔排序
 *
 * @param nums 待排序的数据组
 */
public static void shellSort(int[] nums){
    int length = nums.length;
    int gap = length / 2;
    int temp;
    int index;
    while (gap > 0) {
        for(int i = gap; i < length; i++){
            temp = nums[i];
            index = i - gap;
            while(index >= 0 && nums[index] > temp){
                nums[index + gap] = nums[index];
                index -= gap;
            }
            nums[index + gap] = temp;
        }
        gap /= 2;
    }
}

Tip！！！

希尔排序的时间复杂度目前还没有一个确切的结论，因为其时间复杂度是依赖于argument sequence的，也就是说根据使用不同的“增量”序列的函数，时间复杂度是不同的！而且希尔排序的复杂度分析还涉及到一些数学上目前尚未解决的难题！

但现在普遍的共识是希尔排序的时间复杂度介于O(nlogn) ～ O( )之间，平均时间复杂度大致是O( )，即O( )

5、冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端

算法描述

比较相邻的元素。如果第一个比第二个大，就交换它们两个
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
针对所有的元素重复以上的步骤，除了最后一个
重复步骤1~3，直到排序完成

动画演示
在这里插入图片描述
代码实现

/**
 * 冒泡排序
 *
 * @param nums 待排序的数据组
 */
public static void bubbleSort(int[] nums){
    int length = nums.length;
    int temp;
    for (int i = 0; i < length; i++) {
        for (int j = 0; j < length - 1 - i; j++) {
            if (nums[j] > nums[j + 1]) {
                temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
}

6、快速排序

快速排序（Quick Sort）的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序

算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）

从数列中挑出一个元素，称为 “基准”（pivot）
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序

动画演示
在这里插入图片描述

代码实现

/**
 * 快速排序
 *
 * @param nums 待排序的数据组
 * @param left 左边界
 * @param right 右边界
 */
public static void quickSort(int[] nums, int left, int right){
    if(left < right){
        int benchmark = partition(nums, left, right);
        quickSort(nums, left, benchmark - 1);
        quickSort(nums, benchmark + 1, right);
    }
}

/**
 * 分区
 *
 * @param nums 待分区的数据组
 * @param left 左边界
 * @param right 有边界
 * @return 基准下标
 */
public static int partition(int[] nums, int left, int right){
    int flag = nums[left];
    while (left < right) {
        while (left < right && nums[right] >= flag) {
            right--;
        }
        nums[left] = nums[right];
        while (left < right && nums[left] <= flag) {
            left++;
        }
        nums[right] = nums[left];
    }
    nums[left] = flag;
    return left;
}

7、归并排序

同选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度，但是代价是需要额外的内存空间

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用；归并排序是一种稳定的排序方法，将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序；若将两个有序表合并成一个有序表，称为2路归并
算法描述

把长度为n的输入序列分成两个长度为n/2的子序列
对这两个子序列分别采用归并排序
将两个排序好的子序列合并成一个最终的排序序列

动画演示
在这里插入图片描述

代码实现

/**
 * 归并排序
 *
 * @param nums 待排序的数据组
 * @return 排序后的数据组
 */
public static int[] mergeSort(int[] nums){
    if(nums.length < 2){
        return nums;
    }
    int mid = nums.length / 2;
    int[] left = Arrays.copyOfRange(nums, 0, mid);
    int[] right = Arrays.copyOfRange(nums, mid, nums.length);
    return merge(mergeSort(left), mergeSort(right));
}

/**
 * 归并数据组
 *
 * @param left 左数据组
 * @param right 右数据组
 * @return 归并后的数据组
 */
public static int[] merge(int[] left, int[] right){
    int length = left.length + right.length;
    int[] result = new int[length];
    int index = 0;
    int i = 0;
    int j = 0;
    while (index < length) {
        if (i >= left.length) {
            result[index] = right[j];
            j++;
        } else if (j >= right.length) {
            result[index] = left[i];
            i++;
        } else if (left[i] > right[j]) {
            result[index] = right[j];
            j++;
        } else {
            result[index] = left[i];
            i++;
        }
        index++;
    }
    return result;
}

8、桶排序

桶排序（Bucket Sort）利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定；其工作的原理是，假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序

算法描述

人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize == 5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）
遍历输入数据，并且把数据一个一个放到对应的桶里去
对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序
从不是空的桶里把排好序的数据拼接起来

动画演示
在这里插入图片描述

代码实现

/**
 * 桶排序
 *
 * @param arrayList 待排序的数据组
 * @param bucketSize 桶大小
 * @return 排序后的数据组
 */
public static ArrayList<Integer> bucketSort(ArrayList<Integer> arrayList, int bucketSize) {
    if (arrayList == null || arrayList.size() < 2) {
        return arrayList;
    }
    int min = arrayList.get(0);
    int max = arrayList.get(0);
    // 找出最小值和最大值
    for (Integer integer : arrayList) {
        if (integer < min) {
            min = integer;
        } else if (integer > max) {
            max = integer;
        }
    }
    int bucketCount = (max - min) / bucketSize + 1;
    // 构造桶
    ArrayList<ArrayList<Integer>> buckets = new ArrayList<>(bucketCount);
    for (int i = 0; i < bucketCount; i++) {
        buckets.add(new ArrayList<>());
    }
    // 向桶里添加元素
    int bucketIndex;
    for (Integer integer : arrayList) {
        bucketIndex = (integer - min) / bucketSize;
        buckets.get(bucketIndex).add(integer);
    }
    ArrayList<Integer> result = new ArrayList<>();
    for (int i = 0; i < bucketCount; i++) {
        if (bucketSize == 1) {
            result.addAll(buckets.get(i));
        } else {
            if (bucketCount == 1) {
                bucketSize--;
            }
            ArrayList<Integer> temp = bucketSort(buckets.get(i), bucketSize);
            result.addAll(temp);
        }
    }
    return result;
}

9、计数排序

计数排序（Count Sort）是一种稳定的排序算法，计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数，然后根据数组C来将A中的元素排到正确的位置；它只能对整数进行排序；计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。，作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数

算法描述

找出待排序的数组中最大和最小的元素
统计数组中每个值为i的元素出现的次数，存入数组C的第i项
对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1

动画演示
在这里插入图片描述
代码实现

/**
 * 计数排序
 *
 * @param nums 待排序的数据组
 */
public static void countSort(int[] nums){
    int length = nums.length;
    if (length == 0) {
        return;
    }
    int min = nums[0];
    int max = nums[0];
    // 找出最小值和最大值
    for (int num : nums) {
        if (num < min) {
            min = num;
        } else if (num > max) {
            max = num;
        }
    }
    // 新开辟一个统计区，用来统计各个不同数据出现的次数
    int[] container = new int[max - min + 1];
    for (int num : nums) {
        container[num - min] += 1;
    }
    int index = 0;
    for (int i = 0; i < length; i++) {
        while (container[i] > 0) {
            nums[index] = i + min;
            index++;
            container[i]--;
        }
    }
}

10、基数排序

基数排序（Radix Sort）是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序；最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的

算法描述

取得数组中的最大数，并取得位数，记为maxDigit
arr为原始数组，从最低位开始取每个位组成radix数组
对radix进行计数排序（利用计数排序适用于小范围数的特点）

动画演示
在这里插入图片描述

代码实现

/**
 1. 基数排序
 2.  3. @param nums 待排序的数据组
 */
public static void radixSort(int[] nums) {
    int length = nums.length;
    if (length == 0) {
        return;
    }
    // 找出最大值
    int max = nums[0];
    for (int i = 1; i < length; i++) {
        max = Math.max(max, nums[i]);
    }
    // 计算出最大位数
    int maxDigit = 0;
    while (max != 0) {
        max /= 10;
        maxDigit++;
    }
    int mod = 10;
    int div = 1;
    ArrayList<ArrayList<Integer>> buckets = new ArrayList<>();
    for(int i = 0; i < 10; i++){
        buckets.add(new ArrayList<>());
    }
    int index;
    for(int i = 0; i < maxDigit; i++, mod *= 10, div *= 10){
        for (int num : nums) {
            index = (num % mod) / div;
            buckets.get(index).add(num);
        }
        index = 0;
        for (ArrayList<Integer> bucket : buckets) {
            for (Integer integer : bucket) {
                nums[index] = integer;
                index++;
            }
            bucket.clear();
        }
    }
}

三、特殊、有趣排序算法

1、猴子排序

猴子排序（Bogo Sort），也叫作随机排序；猴子代表乱的意思，猴子排序的意思就是乱排序，直到有序为止；其含义就是把一个无序的数组进行乱排序，然后看其是否会有序，这是个概率性事件，有可能一次之后就有序了，也有可能很多次后依然无序！最佳情况O(n)，平均情况n * n!)，最坏的情况下可以执行到世界末日！

其中将数据组随机排序的实现方法，可以手动生成随机数交换对应的下标数据，也可以调用不同语言提供的内置随机洗牌函数shuffle()，对数据组进行随机打乱

算法描述

传入随机数据组
数据组随机排序
检验数据组是否有序，无序继续，有序了就停止

代码实现

/**
 * 猴子排序
 *
 * @param arrayList 待排序的数据组
 * @return 排序次数
 */
public static int bogoSort(ArrayList<Integer> arrayList) {
    int count = 0;
    while (!isSorted(arrayList)) {
        Collections.shuffle(arrayList);
        count++;
    }
    return count;
}

/**
 * 判断是否已有序
 *
 * @param arrayList 待判断的数据组
 * @return 是否有序
 */
public static boolean isSorted(ArrayList<Integer> arrayList) {
    int length = arrayList.size();
    for (int i = 1; i < length; i++) {
        if (arrayList.get(i - 1) > arrayList.get(i)) {
            return false;
        }
    }
    return true;
}

针对猴子排序，目前也有一种升级版，基于量子理论（但目前还不成熟）的排序：量子猴子排序（Quantum Bogo Sort）！其核心思想是，如果猴子排序随机数据组时，使用量子化随机排列，那么在我们观测这组数据前，它的状态是叠加的，通过这种排列我们就能划分出全排列数量的平行宇宙，然后下面要做的就是去观测这个宇宙，找到一个有序的平行宇宙即可。时间复杂度一直都是O(n)，没有最好、最坏之分！

2、珠排序

珠排序（Bead Sort）的思想是，一行（row）表示一个数字，如果一行里有2颗珠子，该行代表数字2；如果一行里有4颗珠子，该行代表数字4；给定一个数组，数组里有多少个数字，就要有多少行；数组里最大的数字是几，就要准备多少根杆子

准备就绪后，释放珠子，珠子（按重力）下落，就完成了排序

珠排序可以类比于珠子在平行的竖直杆上滑动，就像算盘一样；允许珠子掉落的行为在物理意义上就是允许珠子从高的行掉落至低的行。如果被行a表示的值小于被行a + 1表示的值，那么一些珠子就会从a + 1掉落至a；因为行a不包含足够的珠子防止珠从a + 1行掉落，所以这一定会发生
在这里插入图片描述
用机械装置实现的珠排序类似于计数排序，每一杆上的数字与那些在所有数中等于或大于该数字的数量相当

3、随眠排序

睡眠排序（Sleep Sort）也称为硬件排序，充分利用硬件计时器的资源实现拟态算法

睡眠排序的主要思想是，构造n个线程，它们和这n个数一一对应；初始化后，线程们开始睡眠，等到线程们睡眠相应的时间单位后各自醒来，然后输出对应的数，这样最小的数对应的线程最早醒来，最打的数对应的线程最晚醒来等所有线程都醒来，排序就结束了

代码实现

/**
 * 睡眠排序
 *
 * @param arrayList 待排序的数据组
 */
public static void sleepSort(ArrayList<Integer> arrayList) {
    for (Integer integer : arrayList) {
        sleepThread(integer);
    }
}

/**
 * 创建睡眠线程
 *
 * @param a 睡眠时间
 */
public static void sleepThread(int a){
    Thread thread = new Thread(() -> {
        try {
            Thread.sleep(a);
            System.out.println(a);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    thread.start();
}

4、意大利面排序

意大利面条排序（Spaghetti Sort）的思路是，将数据组对应到不同长度的面条上，每根面条的长度即为对应的数字的大小；比如，对于[1, 4, 2, 8, 9]这个输入，则分别做出长度为1cm、4cm、2cm、8cm、9cm的面条。然后，将这些面条的一头对其，用手抓住，另一头向下。然后慢慢地将手向下垂直下降，第一个触碰到桌面的面条对应的数字则为最大的数字，第二个触碰到的就是第二大的，依次类推

意大利面条排序简直不是一个软件可行的想法 - 它是一种按物理长度排序的“物理”理论方法。基本上它说：“将一堆意大利面条棒推到一个平坦的表面上，使最长的那些比最短的更突出，从而按长度排序它们

最接近的类似想法并且可以实施的是Radix分类。但这仅适用于数据肯定属于固定值集并且足够小以适应可用资源（例如RAM）的情况

参考资料

https://www.latexlive.com
https://blog.csdn.net/zolalad/article/details/11848739
http://www.elecfans.com/d/874748.html
https://blog.csdn.net/weixin_40539125/article/details/93379360

免责申明：相关文章及资料仅供学习交流使用，禁止一切不正当行为，如由此产生相关责任，自行承担

Tip：如需转发或引用相关内容，请务必附带原链接

如果对你有帮助的话，麻烦关注一波，并且点赞、收藏、转发一下哦o(￣︶￣)o！如果有问题或者发现Bug欢迎提出反馈！

6铭记6

关注

5
点赞
踩
24

收藏

觉得还不错? 一键收藏
打赏
2
评论
排序算法详解（Java实现 + 动画演示）

排序算法详解（Java实现 + 动画演示）本篇文章给出了十大经典排序算法和一些奇特、有趣的排序算法实现原理解析，附有时间复杂度、空间复杂度分析和相应的Java实现代码，并给出了动画演示一、十大经典排序算法1、直接选择排序2、堆排序3、直接插入排序4、希尔排序5、冒泡排序6、快速排序7、归并排序8、桶排序9、计数排序10、基数排序二、奇特排序算法1、猴子排序2、珠排序3、随眠排序4、意大利面排序
复制链接

扫一扫