中希尔排序例题代码_超全面分析十大排序算法

点击上方“零一视界”,选择“星标”公众号

资源干货,第一时间送达

e8aef38d84fb7f557364a5ed4d0b861a.png

764f060758cf0738e15b19bd87aa99b3.png

作者 | 不该相遇在秋天

责编 | 程序员小吴

前言

本文全长 14237 字,配有 70 张图片和动画,和你一起一步步看懂排序算法的运行过程。

预计阅读时间 47 分钟,强烈建议先收藏然后通过电脑端进行阅读。

No.1 冒泡排序

冒泡排序无疑是最为出名的排序算法之一,从序列的一端开始往另一端冒泡(你可以从左往右冒泡,也可以从右往左冒泡,看心情),依次比较相邻的两个数的大小(到底是比大还是比小也看你心情)。

07e2d0537ec755e7650b53563b3446b2.gif

冒泡排序动图演示

图解冒泡排序

以 [ 8,2,5,9,7 ] 这组数字来做示例,上图来战:

从左往右依次冒泡,将小的往右移动

1ce45aaccd8ea5b387e8f8e4a59de638.png

冒泡排序1

首先比较第一个数和第二个数的大小,我们发现 2 比 8 要小,那么保持原位,不做改动。位置还是 8,2,5,9,7 。

指针往右移动一格,接着比较:

f0c6b3505a8647f7d530ef85ecbfe7d4.png

冒泡排序2

比较第二个数和第三个数的大小,发现 2 比 5 要小,所以位置交换,交换后数组更新为:[ 8,5,2,9,7 ]。

指针再往右移动一格,继续比较:

789029d25bb585227658f98ba21ae7a6.png

冒泡排序3

比较第三个数和第四个数的大小,发现 2 比 9 要小,所以位置交换,交换后数组更新为:[ 8,5,9,2,7 ]

同样,指针再往右移动,继续比较:

faffab348b54b4c76a51ec5549598ca9.png

冒泡排序4

比较第 4 个数和第 5 个数的大小,发现 2 比 7 要小,所以位置交换,交换后数组更新为:[ 8,5,9,7,2 ]

下一步,指针再往右移动,发现已经到底了,则本轮冒泡结束,处于最右边的 2 就是已经排好序的数字。

通过这一轮不断的对比交换,数组中最小的数字移动到了最右边。

接下来继续第二轮冒泡:

292006469cbebd89a2f92c01b7824476.png

冒泡排序5

be03dc7e06afe32dc95afde1c1ebe2c1.png

冒泡排序6

cedc3dabebc25a3a474b0c50c48bb14e.png

冒泡排序7

由于右边的 2 已经是排好序的数字,就不再参与比较,所以本轮冒泡结束,本轮冒泡最终冒到顶部的数字 5 也归于有序序列中,现在数组已经变化成了[ 8,9,7,5,2 ]。

4b6ce304bf97895b2c8cb02886f58df9.png

冒泡排序8

让我们开始第三轮冒泡吧!

09081a4a5099fec6bbdf07a7ffee043e.png

冒泡排序9

fb0ea11cf5f924c5abf3d14eb1f40ac1.png

冒泡排序10

由于 8 比 7 大,所以位置不变,此时第三轮冒泡也已经结束,第三轮冒泡的最后结果是[ 9,8,7,5,2 ]

紧接着第四轮冒泡:

4aa6fe959c7f1af80908fb79cac278c9.png

冒泡排序11

9 和 8 比,位置不变,即确定了 8 进入有序序列,那么最后只剩下一个数字 9 ,放在末尾,自此排序结束。

代码实现

public static void sort(int arr[]){for( int i = 0 ; i 1 ; i++ ){for(int j = 0;j 1 - i ; j++){int temp = 0;if(arr[j] 1]){
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

冒泡的代码还是相当简单的,两层循环,外层冒泡轮数,里层依次比较,江湖中人人尽皆知。

我们看到嵌套循环,应该立马就可以得出这个算法的时间复杂度为O(n2)。

冒泡优化

冒泡有一个最大的问题就是这种算法不管不管你有序还是没序,闭着眼睛把你循环比较了再说。

比如我举个数组例子:[ 9,8,7,6,5 ],一个有序的数组,根本不需要排序,它仍然是双层循环一个不少的把数据遍历干净,这其实就是做了没必要做的事情,属于浪费资源。

针对这个问题,我们可以设定一个临时遍历来标记该数组是否已经有序,如果有序了就不用遍历了。

public static void sort(int arr[]){for( int i = 0;i 1 ; i++ ){boolean isSort = true;for( int j = 0;j 1 - i ; j++ ){int temp = 0;if(arr[j] 1]){
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                isSort = false;
            }
        }if(isSort){break;
        }
    }
}

No.2 选择排序

选择排序的思路是这样的:首先,找到数组中最小的元素,拎出来,将它和数组的第一个元素交换位置,第二步,在剩下的元素中继续寻找最小的元素,拎出来,和数组的第二个元素交换位置,如此循环,直到整个数组排序完成。

至于选大还是选小,这个都无所谓,你也可以每次选择最大的拎出来排,也可以每次选择最小的拎出来的排,只要你的排序的手段是这种方式,都叫选择排序。

f3c38387e6c5d48340fe61e410d804df.gif

选择排序动画演示

图解选择排序

我们还是以[ 8,2,5,9,7 ]这组数字做例子。

第一次选择,先找到数组中最小的数字 2 ,然后和第一个数字交换位置。(如果第一个数字就是最小值,那么自己和自己交换位置,也可以不做处理,就是一个 if 的事情)

3577bfb9eb74c57f9459a2936258bbe3.png

选择排序1

第二次选择,由于数组第一个位置已经是有序的,所以只需要查找剩余位置,找到其中最小的数字5,然后和数组第二个位置的元素交换。

6bcc9ae3a181f98addb34449d6717b25.png

选择排序2

第三次选择,找到最小值 7 ,和第三个位置的元素交换位置。

d6c4ea73d693a96b303b6d1733642e9b.png

选择排序3

第四次选择,找到最小值8,和第四个位置的元素交换位置。

2bfc97194fc160233f2527ea65f5ab6d.png

选择排序4

最后一个到达了数组末尾,没有可对比的元素,结束选择。

如此整个数组就排序完成了。

代码实现

public static void sort(int arr[]){for( int i = 0;i         int min = i;//最小元素的下标for(int j = i + 1;j             if(arr[j]                 min = j;//找最小值
            }
        }//交换位置int temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
}

双层循环,时间复杂度和冒泡一模一样,都是O(n2)。

No.3 插入排序

插入排序的思想和我们打扑克摸牌的时候一样,从牌堆里一张一张摸起来的牌都是乱序的,我们会把摸起来的牌插入到左手中合适的位置,让左手中的牌时刻保持一个有序的状态。

那如果我们不是从牌堆里摸牌,而是左手里面初始化就是一堆乱牌呢? 一样的道理,我们把牌往手的右边挪一挪,把手的左边空出一点位置来,然后在乱牌中抽一张出来,插入到左边,再抽一张出来,插入到左边,再抽一张,插入到左边,每次插入都插入到左边合适的位置,时刻保持左边的牌是有序的,直到右边的牌抽完,则排序完毕。

9e7c361c72f4bcf6af084c8bc0dfe8e7.gif

插入排序动画演示

图解插入排序

数组初始化:[ 8,2,5,9,7 ],我们把数组中的数据分成两个区域,已排序区域和未排序区域,初始化的时候所有的数据都处在未排序区域中,已排序区域是空。

9e481068407a2bbb9a4f33e2736febbc.png

插入排序1

第一轮,从未排序区域中随机拿出一个数字,既然是随机,那么我们就获取第一个,然后插入到已排序区域中,已排序区域是空,那么就不做比较,默认自身已经是有序的了。(当然了,第一轮在代码中是可以省略的,从下标为1的元素开始即可)

600d5cfb64472d3c1eaac359bbec4cce.png

插入排序2

第二轮,继续从未排序区域中拿出一个数,插入到已排序区域中,这个时候要遍历已排序区域中的数字挨个做比较,比大比小取决于你是想升序排还是想倒序排,这里排升序:

c8eb09c7384d3dbfeb59ccab83d07f67.png

插入排序3

第三轮,排 5 :

e6f0e262dcfffa3ceb1651d5e93f3c0e.png

插入排序4

第四轮,排 9 :

d287783a1bbb5bf849abc24721851134.png

插入排序5

第五轮,排 7

d8524e8705155f8e90a05b607d8e1b5e.png

插入排序6

排序结束。

代码实现

public static void sort(int[] arr) {int n = arr.length;for (int i = 1; i         int value = arr[i];int j = 0;//插入的位置for (j = i-1; j >= 0; j--) {if (arr[j] > value) {
                arr[j+1] = arr[j];//移动数据
            } else {break;
            }
        }
        arr[j+1] = value; //插入数据
    }
}

从代码里我们可以看出,如果找到了合适的位置,就不会再进行比较了,就好比牌堆里抽出的一张牌本身就比我手里的牌都小,那么我只需要直接放在末尾就行了,不用一个一个去移动数据腾出位置插入到中间。

所以说,最好情况的时间复杂度是 O(n),最坏情况的时间复杂度是 O(n2),然而时间复杂度这个指标看的是最坏的情况,而不是最好的情况,所以插入排序的时间复杂度是 O(n2)。

No.4 希尔排序

希尔排序这个名字,来源于它的发明者希尔,也称作“缩小增量排序”,是插入排序的一种更高效的改进版本。

我们知道,插入排序对于大规模的乱序数组的时候效率是比较慢的,因为它每次只能将数据移动一位,希尔排序为了加快插入的速度,让数据移动的时候可以实现跳跃移动,节省了一部分的时间开支。

30f1542c063715a9f6c54135d3d68fb0.gif

希尔排序动画演示

图解希尔排序

待排序数组 10 个数据:

d8524e8705155f8e90a05b607d8e1b5e.png

希尔排序1

假设计算出的排序区间为 4 ,那么我们第一次比较应该是用第 5 个数据与第 1 个数据相比较。

4231532d12c2ca5ef8e7ea66d704a577.png

希尔排序2

调换后的数据为[ 7,2,5,9,8,10,1,15,12,3 ],然后指针右移,第 6 个数据与第 2 个数据相比较。

01fd5408ac7e0524d3cabab2f8f53643.png

希尔排序3

指针右移,继续比较。

6f4e453d69b9e989b77be1834e51af77.png

希尔排序4

6f302cd0a79b5b9aa586c8781ae23c26.png

希尔排序5

如果交换数据后,发现减去区间得到的位置还存在数据,那么继续比较,比如下面这张图,12 和 8 相比较,原地不动后,指针从 12 跳到 8 身上,继续减去区间发现前面还有一个下标为 0 的数据 7 ,那么 8 和 7 相比较。

831ce436bf232225f70afff2bec6b5a8.png

希尔排序6

比较完之后的效果是 7,8,12 三个数为有序排列。

6cf116c94bc4921c886905a5f224f698.png

希尔排序7

当最后一个元素比较完之后,我们会发现大部分值比较大的数据都似乎调整到数组的中后部分了。

假设整个数组比较长的话,比如有 100 个数据,那么我们的区间肯定是四五十,调整后区间再缩小成一二十还会重新调整一轮,直到最后区间缩小为 1,就是真正的排序来了。

4e926dcea866741a7da05397ed89d7c5.png

希尔排序8

指针右移,继续比较:

88a822c0e50c87d6c39e20178db2dba4.png

希尔排序9

重复步骤,即可完成排序,重复的图就不多画了。

我们可以发现,当区间为 1 的时候,它使用的排序方式就是插入排序。

代码实现

public static void sort(int[] arr) {int length = arr.length;//区间int gap = 1;while (gap         gap = gap * 3 + 1;
    }while (gap > 0) {for (int i = gap; i             int tmp = arr[i];int j = i - gap;//跨区间排序while (j >= 0 && arr[j] > tmp) {
                arr[j + gap] = arr[j];
                j -= gap;
            }
            arr[j + gap] = tmp;
        }
        gap = gap / 3;
    }
}

可能你会问为什么区间要以 gap = gap*3 + 1 去计算,其实最优的区间计算方法是没有答案的,这是一个长期未解决的问题,不过差不多都会取在二分之一到三分之一附近。

No.5 归并排序

归并字面上的意思是合并,归并算法的核心思想是分治法,就是将一个数组一刀切两半,递归切,直到切成单个元素,然后重新组装合并,单个元素合并成小数组,两个小数组合并成大数组,直到最终合并完成,排序完毕。

fe5411a929a2841c5f3b91a8ed711f0c.gif

归并排序动画演示

图解归并排序

我们以[ 8,2,5,9,7 ]这组数字来举例

a61d6f76580fa4cc059df4bb606926c5.png

归并排序1

首先,一刀切两半:

af52f2db94bc8f7327898f854680f38f.png

归并排序2

再切:

6e051062b3ac4543fb4af86930197ee7.png

归并排序3

再切

5b82669ff1fd4b4b1b0590032d3fad10.png

归并排序4

粒度切到最小的时候,就开始归并

239460be2cad362e2323efe24c3cd878.png

归并排序5

391940d055fc5f8d573778558e136bcc.png

归并排序6

c95f839ed39f1a8fc3dab68b05da2931.png

归并排序7

数据量设定的比较少,是为了方便图解,数据量为单数,是为了让你看到细节,下面我画了一张更直观的图可能你会更喜欢:

b150d0be86b9840b222803524796858a.png

归并排序8

代码实现

我们上面讲过,归并排序的核心思想是分治,分而治之,将一个大问题分解成无数的小问题进行处理,处理之后再合并,这里我们采用递归来实现:

    public static void sort(int[] arr) {int[] tempArr = new int[arr.length];
        sort(arr, tempArr, 0, arr.length-1);
    }/**
     * 归并排序
     * @param arr 排序数组
     * @param tempArr 临时存储数组
     * @param startIndex 排序起始位置
     * @param endIndex 排序终止位置
     */private static void sort(int[] arr,int[] tempArr,int startIndex,int endIndex){if(endIndex <= startIndex){return;
        }//中部下标int middleIndex = startIndex + (endIndex - startIndex) / 2;//分解
        sort(arr,tempArr,startIndex,middleIndex);
        sort(arr,tempArr,middleIndex + 1,endIndex);//归并
        merge(arr,tempArr,startIndex,middleIndex,endIndex);
    }/**
     * 归并
     * @param arr 排序数组
     * @param tempArr 临时存储数组
     * @param startIndex 归并起始位置
     * @param middleIndex 归并中间位置
     * @param endIndex 归并终止位置
     */private static void merge(int[] arr, int[] tempArr, int startIndex, int middleIndex, int endIndex) {//复制要合并的数据for (int s = startIndex; s <= endIndex; s++) {
            tempArr[s] = arr[s];
        }int left = startIndex;//左边首位下标int right = middleIndex + 1;//右边首位下标for (int k = startIndex; k <= endIndex; k++) {if(left > middleIndex){//如果左边的首位下标大于中部下标,证明左边的数据已经排完了。
                arr[k] = tempArr[right++];
            } else if (right > endIndex){//如果右边的首位下标大于了数组长度,证明右边的数据已经排完了。
                arr[k] = tempArr[left++];
            } else if (tempArr[right]                 arr[k] = tempArr[right++];//将右边的首位排入,然后右边的下标指针+1。
            } else {
                arr[k] = tempArr[left++];//将左边的首位排入,然后左边的下标指针+1。
            }
        }
    }

我们可以发现 merge 方法中只有一个 for 循环,直接就可以得出每次合并的时间复杂度为 O(n) ,而分解数组每次对半切割,属于对数时间 O(log n) ,合起来等于 O(log2n) ,也就是说,总的时间复杂度为 O(nlogn) 。

关于空间复杂度,其实大部分人写的归并都是在 merge 方法里面申请临时数组,用临时数组来辅助排序工作,空间复杂度为 O(n),而我这里做的是原地归并,只在最开始申请了一个临时数组,所以空间复杂度为 O(1)。

如果你对空间复杂度这一块不太了解,可以查看小吴之前的数据结构系列文章---冰与火之歌:「时间」与「空间」复杂度 。

No.6 快速排序

快速排序的核心思想也是分治法,分而治之。它的实现方式是每次从序列中选出一个基准值,其他数依次和基准值做比较,比基准值大的放右边,比基准值小的放左边,然后再对左边和右边的两组数分别选出一个基准值,进行同样的比较移动,重复步骤,直到最后都变成单个元素,整个数组就成了有序的序列。

(周知:动图里面的大于小于写反,小吴修正重新录制后,上传新动图到微信后台却一直失败)

89386898b3060fa8849ee601004f39b5.gif

快速排序动画演示

图解快速排序

我们以[ 8,2,5,0,7,4,6,1 ]这组数字来进行演示

首先,我们随机选择一个基准值:

4b4f866d9cc31b1ab22c75b3284be580.png

快速排序1

与其他元素依次比较,大的放右边,小的放左边:

74d941b7761a65cc601447dadc4b4d8c.png

快速排序2

然后我们以同样的方式排左边的数据:

0681919f06f9f323ef83bb4f6791a1b4.png

快速排序3

继续排 0 和 1 :

11024177341437ddd4f2bdb40ca07277.png

快速排序4

由于只剩下一个数,所以就不用排了,现在的数组序列是下图这个样子:

a3ecc4e3c05e3ad870b592dec9e1c098.png

快速排序5

右边以同样的操作进行,即可排序完成。

单边扫描

快速排序的关键之处在于切分,切分的同时要进行比较和移动,这里介绍一种叫做单边扫描的做法。

我们随意抽取一个数作为基准值,同时设定一个标记 mark 代表左边序列最右侧的下标位置,当然初始为 0 ,接下来遍历数组,如果元素大于基准值,无操作,继续遍历,如果元素小于基准值,则把 mark + 1 ,再将 mark 所在位置的元素和遍历到的元素交换位置,mark 这个位置存储的是比基准值小的数据,当遍历结束后,将基准值与 mark 所在元素交换位置即可。

代码实现:

public static void sort(int[] arr) {
    sort(arr, 0, arr.length - 1);
}private static void sort(int[] arr, int startIndex, int endIndex) {if (endIndex <= startIndex) {return;
    }//切分int pivotIndex = partitionV2(arr, startIndex, endIndex);
    sort(arr, startIndex, pivotIndex-1);
    sort(arr, pivotIndex+1, endIndex);
}private static int partition(int[] arr, int startIndex, int endIndex) {int pivot = arr[startIndex];//取基准值int mark = startIndex;//Mark初始化为起始下标for(int i=startIndex+1; i<=endIndex; i++){if(arr[i]            //小于基准值 则mark+1,并交换位置。
            mark ++;int p = arr[mark];
            arr[mark] = arr[i];
            arr[i] = p;
        }
    }//基准值与mark对应元素调换位置
    arr[startIndex] = arr[mark];
    arr[mark] = pivot;return mark;
}

双边扫描

另外还有一种双边扫描的做法,看起来比较直观:我们随意抽取一个数作为基准值,然后从数组左右两边进行扫描,先从左往右找到一个大于基准值的元素,将下标指针记录下来,然后转到从右往左扫描,找到一个小于基准值的元素,交换这两个元素的位置,重复步骤,直到左右两个指针相遇,再将基准值与左侧最右边的元素交换。

我们来看一下实现代码,不同之处只有 partition 方法:

public static void sort(int[] arr) {
    sort(arr, 0, arr.length - 1);
}private static void sort(int[] arr, int startIndex, int endIndex) {if (endIndex <= startIndex) {return;
    }//切分int pivotIndex = partition(arr, startIndex, endIndex);
    sort(arr, startIndex, pivotIndex-1);
    sort(arr, pivotIndex+1, endIndex);
}private static int partition(int[] arr, int startIndex, int endIndex) {int left = startIndex;int right = endIndex;int pivot = arr[startIndex];//取第一个元素为基准值while (true) {//从左往右扫描while (arr[left] <= pivot) {
            left++;if (left == right) {break;
            }
        }//从右往左扫描while (pivot             right--;if (left == right) {break;
            }
        }//左右指针相遇if (left >= right) {break;
        }//交换左右数据int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }//将基准值插入序列int temp = arr[startIndex];
    arr[startIndex] = arr[right];
    arr[right] = temp;return right;
}

极端情况

快速排序的时间复杂度和归并排序一样,O(n log n),但这是建立在每次切分都能把数组一刀切两半差不多大的前提下,如果出现极端情况,比如排一个有序的序列,如[ 9,8,7,6,5,4,3,2,1 ],选取基准值 9 ,那么需要切分 n - 1 次才能完成整个快速排序的过程,这种情况下,时间复杂度就退化成了 O(n2),当然极端情况出现的概率也是比较低的。

所以说,快速排序的时间复杂度是 O(nlogn),极端情况下会退化成 O(n2),为了避免极端情况的发生,选取基准值应该做到随机选取,或者是打乱一下数组再选取。

另外,快速排序的空间复杂度为 O(1)。

No.7 堆排序

堆排序顾名思义,是利用堆这种数据结构来进行排序的算法。

如果你不了解堆这种数据结构,可以查看小吴之前的数据结构系列文章---看动画轻松理解堆

如果你了解堆这种数据结构,你应该知道堆是一种优先队列,两种实现,最大堆和最小堆,由于我们这里排序按升序排,所以就直接以最大堆来说吧。

我们完全可以把堆(以下全都默认为最大堆)看成一棵完全二叉树,但是位于堆顶的元素总是整棵树的最大值,每个子节点的值都比父节点小,由于堆要时刻保持这样的规则特性,所以一旦堆里面的数据发生变化,我们必须对堆重新进行一次构建。

既然堆顶元素永远都是整棵树中的最大值,那么我们将数据构建成堆后,只需要从堆顶取元素不就好了吗? 第一次取的元素,是否取的就是最大值?取完后把堆重新构建一下,然后再取堆顶的元素,是否取的就是第二大的值? 反复的取,取出来的数据也就是有序的数据。

27e1a80d62ae67810538121e0db37d84.gif

堆排序动画演示

图解堆排序

我们以[ 8,2,5,9,7,3 ]这组数据来演示。

首先,将数组构建成堆。

c33dc5205554df32b8afa8153b7e06dc.png

堆排序1

既然构建成堆结构了,那么接下来,我们取出堆顶的数据,也就是数组第一个数 9 ,取法是将数组的第一位和最后一位调换,然后将数组的待排序范围 -1。

d5a7333eaf1f8f27c7dd061de9aaff9e.png

堆排序2

现在的待排序数据是[ 3,8,5,2,7 ],我们继续将待排序数据构建成堆。

39cb8c32474856d27fcc1bbc0d570c7a.png

堆排序3

取出堆顶数据,这次就是第一位和倒数第二位交换了,因为待排序的边界已经减 1 。

50aa2fb833a8bb6207f338658a79f409.png

堆排序4

继续构建堆

32e5f881c173eed93fd5b95af541b410.png

堆排序5

从堆顶取出来的数据最终形成一个有序列表,重复的步骤就不再赘述了,我们来看一下代码实现。

代码实现

public static void sort(int[] arr) {int length = arr.length;//构建堆
    buildHeap(arr, length);for ( int i = length - 1; i > 0; i-- ) {//将堆顶元素与末位元素调换int temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;//数组长度-1 隐藏堆尾元素
        length--;//将堆顶元素下沉 目的是将最大的元素浮到堆顶来
        sink(arr, 0, length);
    }
}private static void buildHeap(int[] arr, int length) {for (int i = length / 2; i >= 0; i--) {
        sink(arr, i, length);
    }
}/**
 * 下沉调整
 * @param arr 数组
 * @param index 调整位置
 * @param length 数组范围
 */private static void sink(int[] arr, int index, int length) {int leftChild = 2 * index + 1;//左子节点下标int rightChild = 2 * index + 2;//右子节点下标int present = index;//要调整的节点下标//下沉左边if (leftChild  arr[present]) {
        present = leftChild;
    }//下沉右边if (rightChild  arr[present]) {
        present = rightChild;
    }//如果下标不相等 证明调换过了if (present != index) {//交换值int temp = arr[index];
        arr[index] = arr[present];
        arr[present] = temp;//继续下沉
        sink(arr, present, length);
    }
}

堆排序和快速排序的时间复杂度都一样是 O(nlogn)。

No.8 计数排序

计数排序是一种非基于比较的排序算法,我们之前介绍的各种排序算法几乎都是基于元素之间的比较来进行排序的,计数排序的时间复杂度为 O(n + m ),m 指的是数据量,说的简单点,计数排序算法的时间复杂度约等于 O(n),快于任何比较型的排序算法。

b47326d5d516f8cb115ff2ef2bf9e806.gif

计数排序动画演示

图解计数排序

以下以[ 3,5,8,2,5,4 ]这组数字来演示。

首先,我们找到这组数字中最大的数,也就是 8,创建一个最大下标为 8 的空数组 arr 。

0d4be998627ffba15fbf2a402a87ae38.png

计数排序1

遍历数据,将数据的出现次数填入arr中对应的下标位置中。

9bb156c20480254d67f5d041da52a934.png

计数排序2

遍历 arr ,将数据依次取出即可。

a0353534df256e13fbd6d554f7afd405.png

计数排序3

代码实现

public static void sort(int[] arr) {//找出数组中的最大值int max = arr[0];for (int i = 1; i         if (arr[i] > max) {
            max = arr[i];
        }
    }//初始化计数数组int[] countArr = new int[max + 1];//计数for (int i = 0; i         countArr[arr[i]]++;
        arr[i] = 0;
    }//排序int index = 0;for (int i = 0; i         if (countArr[i] > 0) {
            arr[index++] = i;
        }
    }
}

稳定排序

有一个需求就是当对成绩进行排名次的时候,如何在原来排前面的人,排序后还是处于相同成绩的人的前面。

解题的思路是对 countArr 计数数组进行一个变形,变来和名次挂钩,我们知道 countArr 存放的是分数的出现次数,那么其实我们可以算出每个分数的最大名次,就是将 countArr 中的每个元素顺序求和。

如下图:

04d2299b6725cfb7e89e6cce05dad9e7.png

稳定排序

变形之后是什么意思呢?

我们把原数组[ 2,5,8,2,5,4 ]中的数据依次拿来去 countArr 去找,你会发现 3 这个数在 countArr[3] 中的值是 2 ,代表着排名第二名,(因为第一名是最小的 2,对吧?),5 这个数在 countArr[5] 中的值是 5 ,为什么是 5 呢?我们来数数,排序后的数组应该是[ 2,3,4,5,5,8 ],5 的排名是第五名,那 4 的排名是第几名呢?对应 countArr[4] 的值是 3 ,第三名,5 的排名是第五名是因为 5 这个数有两个,自然占据了第 4 名和第 5 名。

所以我们取排名的时候应该特别注意,原数组中的数据要从右往左取,从 countArr 取出排名后要把 countArr 中的排名减 1 ,以便于再次取重复数据的时候排名往前一位。

对应代码实现:

public static void sort(int[] arr) {//找出数组中的最大值int max = arr[0];for (int i = 1; i         if (arr[i] > max) {
            max = arr[i];
        }
    }//初始化计数数组int[] countArr = new int[max + 1];//计数for (int i = 0; i         countArr[arr[i]]++;
    }//顺序累加for (int i = 1; i 1; ++i) {
        countArr[i] = countArr[i-1] + countArr[i];
    }//排序后的数组int[] sortedArr = new int[arr.length];//排序for (int i = arr.length - 1; i >= 0; --i) {
        sortedArr[countArr[arr[i]]-1] = arr[i];
        countArr[arr[i]]--;
    }//将排序后的数据拷贝到原数组for (int i = 0; i         arr[i] = sortedArr[i];
    }
}

计数局限性

计数排序的毛病很多,我们来找找 bug 。

如果我要排的数据里有 0 呢? int[] 初始化内容全是 0 ,排毛线。

如果我要排的数据范围比较大呢?比如[ 1,9999 ],我排两个数你要创建一个 int[10000] 的数组来计数?

对于第一个 bug ,我们可以使用偏移量来解决,比如我要排[ -1,0,-3 ]这组数字,这个简单,我全给你们加 10 来计数,变成[ 9,10,7 ]计完数后写回原数组时再减 10。不过有可能也会踩到坑,万一你数组里恰好有一个 -10,你加上 10 后又变 0 了,排毛线。

对于第二个 bug ,确实解决不了,如果是[ 9998,9999 ]这种虽然值大但是相差范围不大的数据我们也可以使用偏移量解决,比如这两个数据,我减掉 9997 后只需要申请一个 int[3] 的数组就可以进行计数。

由此可见,计数排序只适用于正整数并且取值范围相差不大的数组排序使用,它的排序的速度是非常可观的。

No.9 桶排序

桶排序可以看成是计数排序的升级版,它将要排的数据分到多个有序的桶里,每个桶里的数据再单独排序,再把每个桶的数据依次取出,即可完成排序。

433ef08ca7bc0f4637c63e1608ced758.gif

桶排序动画演示

图解桶排序

我们拿一组计数排序啃不掉的数据 [ 500,6123,1700,10,9999 ] 来举例。

第一步,我们创建 10 个桶,分别来装 0-1000 、1000-2000 、 2000-3000 、 3000-4000 、 4000-5000 、5000-6000、 6000-7000 、7000-8000 、8000-9000 区间的数据。

a6d41c5dfb953f56d0c2e040349dd689.png

桶排序1

第二步,遍历原数组,对号入桶。

9613402ac17f98368f8b5d3c039de795.png

桶排序2

第三步,对桶中的数据进行单独排序,只有第一个桶中的数量大于 1 ,显然只需要排第一个桶。

28a16187d1a9fdd3165151aa66e30f4f.png

桶排序3

最后,依次将桶中的数据取出,排序完成。

7825d3f3a11eab2f262ea8591c1ce7e8.png

桶排序4

代码实现

这个桶排序乍一看好像挺简单的,但是要敲代码就需要考虑几个问题了。

桶这个东西怎么表示?

怎么确定桶的数量?

桶内排序用什么方法排?

代码如下:

public static void sort(int[] arr){//最大最小值int max = arr[0];int min = arr[0];int length = arr.length;for(int i=1; i        if(arr[i] > max) {
            max = arr[i];
        } else if(arr[i]             min = arr[i];
        }
    }//最大值和最小值的差int diff = max - min;//桶列表
    ArrayList> bucketList = new ArrayList<>();for(int i = 0; i         bucketList.add(new ArrayList<>());
    }//每个桶的存数区间float section = (float) diff / (float) (length - 1);//数据入桶for(int i = 0; i         //当前数除以区间得出存放桶的位置 减1后得出桶的下标int num = (int) (arr[i] / section) - 1;if(num 0){
            num = 0;
        }
        bucketList.get(num).add(arr[i]);
    }//桶内排序for(int i = 0; i         //jdk的排序速度当然信得过
        Collections.sort(bucketList.get(i));
    }//写入原数组int index = 0;for(ArrayList arrayList : bucketList){for(int value : arrayList){
            arr[index] = value;
            index++;
        }
    }
}

桶当然是一个可以存放数据的集合,我这里使用 arrayList ,如果你使用 LinkedList 那其实也是没有问题的。

桶的数量我认为设置为原数组的长度是合理的,因为理想情况下每个数据装一个桶。

数据入桶的映射算法其实是一个开放性问题,我承认我这里写的方案并不佳,因为我测试过不同的数据集合来排序,如果你有什么更好的方案或想法,欢迎留言讨论。

桶内排序为了方便起见使用了当前语言提供的排序方法,如果对于稳定排序有所要求,可以选择使用自定义的排序算法。

桶排序的思考及其应用

在额外空间充足的情况下,尽量增大桶的数量,极限情况下每个桶只有一个数据时,或者是每只桶只装一个值时,完全避开了桶内排序的操作,桶排序的最好时间复杂度就能够达到 O(n)。

比如高考总分 750 分,全国几百万人,我们只需要创建 751 个桶,循环一遍挨个扔进去,排序速度是毫秒级。

但是如果数据经过桶的划分之后,桶与桶的数据分布极不均匀,有些数据非常多,有些数据非常少,比如[ 8,2,9,10,1,23,53,22,12,9000 ]这十个数据,我们分成十个桶装,结果发现第一个桶装了 9 个数据,这是非常影响效率的情况,会使时间复杂度下降到 O(nlogn),解决办法是我们每次桶内排序时判断一下数据量,如果桶里的数据量过大,那么应该在桶里面回调自身再进行一次桶排序。

No.10 基数排序

基数排序是一种非比较型整数排序算法,其原理是将数据按位数切割成不同的数字,然后按每个位数分别比较。
假设说,我们要对 100 万个手机号码进行排序,应该选择什么排序算法呢?排的快的有归并、快排时间复杂度是 O(nlogn),计数排序和桶排序虽然更快一些,但是手机号码位数是11位,那得需要多少桶?内存条表示不服。

这个时候,我们使用基数排序是最好的选择。

42b754f663c034691a39be926663ed68.gif

图解基数排序

我们以[ 892, 846, 821, 199, 810,700 ]这组数字来做例子演示。

首先,创建十个桶,用来辅助排序。

1d61e460a7a6789ad08593ce7a22bff7.png

基数排序1

先排个位数,根据个位数的值将数据放到对应下标值的桶中。

950ba4cb8a46eca421d4e68779989204.png

基数排序2

排完后,我们将桶中的数据依次取出。

23e14cf39f89ef2f20a1a4603e4ea169.png

基数排序3

那么接下来,我们排十位数。

e6e6e79b05a841f6cd5e9aee0caf446e.png

基数排序4

最后,排百位数。

c4f56f2067d170ff6f8ee8351a29e55c.png

基数排序5

排序完成。

代码实现

基数排序可以看成桶排序的扩展,也是用桶来辅助排序,代码如下:

public static void sort(int[] arr){int length = arr.length;//最大值int max = arr[0];for(int i = 0;i         if(arr[i] > max){
            max = arr[i];
        }
    }//当前排序位置int location = 1;//桶列表
    ArrayList> bucketList = new ArrayList<>();//长度为10 装入余数0-9的数据for(int i = 0; i 10; i++){
        bucketList.add(new ArrayList());
    }while(true)
    {//判断是否排完int dd = (int)Math.pow(10,(location - 1));if(max             break;
        }//数据入桶for(int i = 0; i         {//计算余数 放入相应的桶int number = ((arr[i] / dd) % 10);
            bucketList.get(number).add(arr[i]);
        }//写回数组int nn = 0;for (int i=0;i<10;i++){int size = bucketList.get(i).size();for(int ii = 0;ii                 arr[nn++] = bucketList.get(i).get(ii);
            }
            bucketList.get(i).clear();
        }
        location++;
    }
}

其实它的思想很简单,不管你的数字有多大,按照一位一位的排,0 - 9 最多也就十个桶:先按权重小的位置排序,然后按权重大的位置排序。

当然,如果你有需求,也可以选择从高位往低位排。

推荐阅读

有趣的学习《操作系统真象还原》

数据分析必备,《利用Python进行数据分析》推荐

有趣的算法书《算法图解》推荐

轻松学习网络知识,《图解HTTP》推荐

8417e712d9cf3f4325963c5365df9b79.png

欢迎关注我们,收获资源干货

a0eb13aa4547e4443eacce0214bca9e6.png

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/488629.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

eslint规范_代码规范化之Vue篇

写在前面代码规范化的重要性不在这里展开了。这一篇讲了Vue项目下如何做代码规范化的事情&#xff0c;主要涉及了eslint、prettier、huskylint-staged、onchange、editorConfig这几个角色。另外&#xff0c;虽然配置限于Vue项目&#xff0c;但整个思路也可以作为其他项目代码规…

人类为什么不会被人工智能取代?

来源&#xff1a;人机与认知实验室〔摘要〕文章旨在对人工智能的技术本质进行分析&#xff0c;以回应为什么人类不会被人工智能取代的问题。通过历史分析的方法&#xff0c;以“器官投影说”等技术哲学思想作为分析工具&#xff0c;回顾了人工智能技术的历程。发现在理论上&…

工作组服务器操作系统,工作组服务器操作系统

工作组服务器操作系统 内容精选换一换弹性云服务器操作系统无法正常启动时&#xff0c;或云服务器系统运行正常&#xff0c;但需要对系统进行优化&#xff0c;使其在最优状态下工作时&#xff0c;用户可以使用重装弹性云服务器的操作系统功能。重装操作系统后弹性云服务器IP地址…

270 扩展固态硬盘_游戏人的扩展坞应该是怎样?

为何现在越来越多的游戏爱好者开始使用游戏扩展坞&#xff1f;原因其实很简单&#xff0c;如今游戏笔记本也慢慢往轻薄本发展&#xff0c;拓展坞的加入可让笔记本实现台式机的玩机体验&#xff0c;通过扩展坞可以实现现在许多游戏本不具备的功能&#xff0c;比如外接超高清显示…

几十亿打水漂!世界最大移动通信展MWC因疫情33年来首次取消,多方损失惨重...

资料来源&#xff1a;新智元、AI前线物联网智库 整理发布转载请注明来源和出处北京时间2月13日早晨&#xff08;今晨&#xff09;&#xff0c;世界移动通讯展&#xff08;MWC&#xff09;主办方GSMA正式宣布取消原定于本月24日至27日在西班牙巴塞罗那举办的MWC2020展会。这也是…

eslint vscode 自动格式化_vscode保存代码,自动按照eslint规范格式化代码设置

vscode保存代码&#xff0c;自动按照eslint规范格式化代码设置编辑器代码风格一致&#xff0c;是前端代码规范的一部分。我们现在前端绝大部分都在使用eslint&#xff0c;或者将要把代码改为eslint&#xff0c;那么此时我们怎么方便使用这个规范呢&#xff0c;下面我来介绍一下…

虚拟化服务器类型,虚拟化服务器类型

虚拟化服务器类型 内容精选换一换本次Ceph集群使用TaiShan服务器部署&#xff0c;三个Ceph节点采用三台为TaiShan 200服务器(型号2280)&#xff1b;K8s节点两台均采用TaiShan 200服务器(型号2280)。每台服务器配备4个SAS HDD&#xff0c;一块用做OS盘&#xff0c;三块用作存储盘…

异常01

一、异常对象的产生原因和处理方式 二、异常的抛出 1 public class Demo01 {2 /*3 * Throwable:Exception、Error4 * Exception->RuntimeException5 * 异常中的关键字&#xff1a;throw,在方法内部&#xff0c;抛出异常6 * 7 * 方法中声明…

核酸和CT同时用, 听谁的?——兼释一天新增一万多

笔者两天前的文章 新冠病毒检验的可信度和概率预测分析了为什么核酸检验会漏报&#xff0c;为什么要使用CT辅助确诊。今天爆出新闻&#xff0c;新增确诊约15000人&#xff0c;但是其中临床13332人。临床以前是疑似和确诊之间的病人&#xff0c;为什么这么多临床病人都算是确诊&…

access update语句执行_统一VBA中SQL语句执行的方法

要在 Access 中用 VBA 中执行操作查询&#xff0c;在不创建查询对象的前提下&#xff0c;一般主要有3种方法&#xff1a;1. Access本身的方法&#xff1a;DoCmd.RunSQL strSQL2. DAO的方法&#xff1a;CurrentDb.Execute strSQL3. ADO的方法&#xff1a;CurrentProject.Connect…

一个人越聪明他大脑皮层神经元之间的联系就越少

来源&#xff1a;科学杂志 这是波鸿鲁尔大学的神经科学家与ErhanGen博士和Christoph Fraenz博士合作进行的一项研究的结果。这项研究是使用特定的神经影像技术进行的&#xff0c;该技术可在微观结构水平上洞悉大脑的连线。波鸿生物心理学研究小组的团队与阿尔伯克基新墨西哥大学…

git查询当前目录下的文件列表_linux下查找文件,看这篇就够了

linux下文件查找命令用法总结。前言我们经常需要在linux系统中查找一个文件&#xff0c;或需要知道哪些文件包含已知的特有信息&#xff0c;便于快速对比排查、分析问题&#xff0c;那么如何准确高效查找呢&#xff1f;其实在linux下可查找文件的命令不止一个&#xff0c;命令附…

人工智能如何推动神经科技发展?

来源 | Forbes作者 | Margaretta Colangelo编译 | 科技行者神经科技以人类神经系统原理为基础&#xff0c;旨在研究人类大脑这一极为复杂的模型架构。在实际作用方面&#xff0c;神经科技将帮助研究人员了解大脑功能与引发功能障碍的原因&#xff0c;并助力医生治疗各类神经系…

tomcat lifecyclelistener_继续,来聊聊Tomcat的容器

作者&#xff1a;不学无数的程序员链接&#xff1a;https://urlify.cn/jYZFFf在这篇文章《Tomcat是如何运行的&#xff1f;整体架构又是怎样的&#xff1f;》中我们简单介绍了容器的概念&#xff0c;并且说了在容器中所有子容器的父接口是Container。在死磕Tomcat系列(2)——En…

如何与病毒搏斗?这部BBC“史诗级大片”告诉你答案

来源&#xff1a;惠在湖北 我们知道&#xff0c;在目前没有特效药和疫苗的情况下&#xff0c;被治愈的新型冠状病毒肺炎患者&#xff0c;离不开医学的帮助&#xff0c;而治愈的关键&#xff0c;依靠的是人体自身的免疫力。病毒是如何入侵的&#xff1f;免疫力从何而来&#xff…

markdown 行内公式_使用Markdown快速编辑公众号技巧之mdnice

请使用 Chrome 浏览器。请阅读下方文本熟悉工具使用方法&#xff0c;本文可直接拷贝到微信中预览。1 Markdown Nice 简介支持自定义样式的 Markdown 编辑器支持微信公众号、知乎和稀土掘金欢迎扫码回复「排版」加入用户群2 主题https://preview.mdnice.com/themes/欢迎提交主题…

AI人必看!89页全网最全清华知识图谱报告(附PDF)

来源&#xff1a;智东西知识图谱&#xff08;Knowledge Graph&#xff09;是人工智能的重要分支技术&#xff0c;它在2012年由谷歌提出&#xff0c;成为建立大规模知识的杀手锏应用&#xff0c;在搜索、自然语言处理、智能助手、电子商务等领域发挥着重要作用。知识图谱与大数据…

AI战“疫”!人工智能在疫情中的重要作用

来源&#xff1a;腾讯新闻网新冠肺炎疫情牵动着全国人民的心&#xff01;在防控疫情部署落实工作中&#xff0c;上海着力将人工智能等现代信息技术深入应用于疫情态势研判、传播路径分析、精准防控、有效治疗及后续治理等各工作环节。通过提供更加精准有效的科学决策依据&#…

linux 判断指针是否可读_Linux进程间通信——消息队列

概念什么是消息队列&#xff1f;消息队列亦称报文队列&#xff0c;也叫做信箱。是Linux的一种通信机制&#xff0c;这种通信机制传递的数据具有某种结构&#xff0c;而不是简单的字节流。消息队列的本质其实是一个内核提供的链表&#xff0c;内核基于这个链表&#xff0c;实现了…

【人工智能】中科院2019全球人工智能发展白皮书!八大关键技术中国崛起中,国产AI芯片耀眼...

来源&#xff1a;产业智能官人工智能是一个很宽泛的概念&#xff0c;概括而言是对人的意识和思维过程的模拟&#xff0c;利用机器学习和数据分析方法赋予机器类人的能力。人工智能将提升社会劳动生产率&#xff0c;特别是在有效降低劳动成本、优化产品和服务、创造新市场和就业…