声明:此文转载公众号(帅地玩编程),强烈推荐此公众号,文章特别棒。
原文链接:https://mp.weixin.qq.com/s/IAZnN00i65Ad3BicZy5kzQ
(大家点原文看吧,我这里稍微按照自己的思路修改了一下下,程序部分我写成了C++,给出了完整程序,原文是JAVA的功能函数)
术语铺垫
有些人可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度,这里简单解释一下:
区分相同数的相对位置
1、稳定排序:如果 a 原本在 b 的前面,且 a == b,排序之后 a 仍然在 b 的前面,则为稳定排序。
2、非稳定排序:如果 a 原本在 b 的前面,且 a == b,排序之后 a 可能不在 b 的前面,则为非稳定排序。
区分是否申请多余的存储空间
3、原地排序:原地排序指在排序过程中不申请多余的存储空间,只利用原来存储待排数据的存储空间进行比较和交换的数据排序。
4、非原地排序:需要利用额外的数组来辅助排序。
复杂度
5、时间复杂度:一个算法执行所消耗的时间。
6、空间复杂度:运行完一个算法所需的内存大小。
十大排序讲解顺序
-
选择排序
-
插入排序
-
冒泡排序
-
非优化版本
-
优化版本
-
希尔排序
-
归并排序
-
递归式归并排序
-
非递归式归并排序
-
-
快速排序
-
堆排序
-
基数排序
-
非优化版本
-
优化版本
-
-
桶排序
-
基数排序
另:
代码说明:代码我自己写的,并且都是经过好几组数据测试通过,应该没啥问题,如有错,还请反馈下,谢谢。
图片说明:图片和动画都是在百度搜索的,如有侵权,还望联系我删除,谢谢
1、选择排序
过程简单描述:(每次都选择数组中最小的数据将它通过交换的方式放到应该的位置)
首先,找到数组中最小的那个元素,其次,将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就和自己交换)。其次,在剩下的元素中找到最小的元素,将它与数组的第二个元素交换位置。如此往复,直到将整个数组排序。这种方法我们称之为选择排序。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:https://mp.weixin.qq.com/s/KaPFukstz-0B89KLv49dUw
代码如下:
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int a[10010];
void swap(int &x,int &y){
int temp;
temp=x;
x=y;
y=temp;
}
int SelSort(int n) {
//排序 两层循环,每层循环都在无序数据中找到一个最小值,放入正确位置
for(int i=0;i<n-1;i++){
int min=i;//每次都需要初始化,将无序数据中第一个初始化为最小值
for(int j=i+1;j<n;j++) {
if(a[min]>a[j]){
min=j;//只记录最小值的下标
}
}
swap(a[min],a[i]); //每次循环结束进行交换
}
//return a;
}
int main()
{
int n=4;
for(int i=0;i<n;i++){
cin>>a[i];
}
SelSort(n);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}//数组需要一个一个输出
cout<<endl;
return 0;
}
性质:
1、时间复杂度:O(n2) (两层循环)
2、空间复杂度:O(1) (交换时temp)
3、非稳定排序 (将第一个元素默认为最小元素,只要遇到比它小的数据就交换 例如:5 6 5 2 3 第一次后变为2 6 5 5 3 )
4、原地排序(排序时数组不需要申请新的位置)
2、插入排序(小规模数据数据或者基本有序或者时十分高效)
我们在玩打牌的时候,你是怎么整理那些牌的呢?一种简单的方法就是一张一张的来,将每一张牌插入到其他已经有序的牌中的适当位置。当我们给无序数组做排序的时候,为了要插入元素,我们需要腾出空间,将其余所有元素在插入之前都向右移动一位,这种算法我们称之为插入排序。
过程简单描述:(将第一个数字默认为排好序的,从第二个开始为未排好序的(循环从第2个开始),内循环寻找位置从后向前扫描,找到位置别的腾位置)
1、从数组第2个元素开始抽取元素。
2、把它与左边第一个元素比较,如果左边第一个元素比它大,则继续与左边第二个元素比较下去,直到遇到不比它大的元素,然后插到这个元素的右边。
3、继续选取第3,4,….n个元素,重复步骤 2 ,选择适当的位置插入。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:https://mp.weixin.qq.com/s/VNvGXsTpGgzUhQlRJ1GsTA
代码如下:
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int a[10010];
int InsSort(int n) {
//第一个默认有序
//无序区,第二个到最后一个 ,遍历无序区
//有序区,第一个 ,遍历有序区,从有序区(终止于第一个元素)倒序查找正确位置
int cur;
for(int i=1;i<n;i++){//一遍历 无序区
cur=a[i];//第二个开始排序,第二个数据与别的进行比较
//内循环,倒序查找合适位置
// cur<a[j] 无序区的第一个元素应该比有序区的大,大的话没必要遍历,因为相对位置正确,遍历也没有结果
//条件能写到 for就不要在内部if,容易死循环出不来,无结果
int j=i-1;//因为一层循环外要用,,有序区的最后一个元素
for(;(j>=0)&&(cur<a[j]);j--) {
a[j+1]=a[j];//腾位置,从后往前腾
} //一次循环后,得到的只是相对位置,不一定会放在正确位置
a[j+1]=cur; //每次循环结束进行交换
}
//return a;
}
int main()
{
int n=4;
for(int i=0;i<n;i++){
cin>>a[i];
}
InsSort(n);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}//数组需要一个一个输出
cout<<endl;
return 0;
}
性质:
1、时间复杂度:O(n2)
2、空间复杂度:O(1)
3、稳定排序 (比较寻找正确位置的时候,遇到相同的不移动)
4、原地排序(有申请空间 但是少 只是辅助)
第一趟排序完以后得到的只是相对位置,不一定放在正确位置
3、冒泡排序
1、把第一个元素与第二个元素比较,如果第一个比第二个大,则交换他们的位置。接着继续比较第二个与第三个元素,如果第二个比第三个大,则交换他们的位置….
我们对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样一趟比较交换下来之后,排在最右的元素就会是最大的数。
除去最右的元素,我们对剩余的元素做同样的工作,如此重复下去,直到排序完成。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:https://mp.weixin.qq.com/s/6mzB4X5D8AY9F20c_mlQFQ
代码如下
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int a[10010];
void swap(int &x,int &y){
int temp;
temp=x;
x=y;
y=temp;
}
int BubbleSort(int n) {
//到达倒数第二个,相邻两两同时移动,控制趟数
for(int i=0;i<n-1;i++){
//内循环控制第 i+1趟(因为i从0开始)所比较的次数,第 i +1 趟比较了 N - 1 -i 次
for(int j=0;j<n-1-i;j++) {
if(a[j]>a[j+1]){
swap(a[j],a[j+1]);
}
}
}
}
int main()
{
int n=4;
for(int i=0;i<n;i++){
cin>>a[i];
}
BubbleSort(n);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}
性质:1、时间复杂度:O(n2) 2、空间复杂度:O(1) 3、稳定排序 4、原地排序
一趟排序以后,最大的或最小的放在正确位置
优化一下冒泡排序的算法
假如从开始的第一对到结尾的最后一对,相邻的元素之间都没有发生交换的操作,这意味着右边的元素总是大于等于左边的元素,此时的数组已经是有序的了,我们无需再对剩余的元素重复比较下去了。
代码如下:(添加标志位)
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int a[10010];
void swap(int &x,int &y){
int temp;
temp=x;
x=y;
y=temp;
}
int BubbleSort(int n) {
//到达倒数第二个,相邻两两同时移动,控制趟数
for(int i=0;i<n-1;i++){
bool flag=true;
//内循环控制第 i+1趟(因为i从0开始)所比较的次数,第 i +1 趟比较了 N - 1 -i 次
for(int j=0;j<n-1-i;j++) {
if(a[j]>a[j+1]){
flag=false;//只要发生交换就说明无序
swap(a[j],a[j+1]);
}
}
//遍历后没有发生交换,说明已经有序,不要在进行了
if(flag){
break;
}
}
}
int main()
{
int n=4;
for(int i=0;i<n;i++){
cin>>a[i];
}
BubbleSort(n);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}
4、希尔排序(较大规模并且无序的数据也非常有效率)
希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序,如果数组的最大值刚好是在第一位,要将它挪到正确的位置就需要 n - 1 次移动。也就是说,原数组的一个元素如果距离它正确的位置很远的话,则需要与相邻元素交换很多次才能到达正确的位置,这样是相对比较花时间了。
希尔排序就是为了加快速度简单地改进了插入排序,交换不相邻的元素以对数组的局部进行排序。
首先它把较大的数据集合分割成若干个小组(逻辑上分组),然后对每一个小组分别进行插入排序,此时,插入排序所作用的数据量比较小(每一个小组),插入的效率比较高
希尔排序的思想是采用插入排序的方法,先让数组中任意间隔为 h 的元素有序,刚开始 h 的大小可以是 h = n / 2,接着让 h = n / 4,让 h 一直缩小,当 h = 1 时,也就是此时数组中任意间隔为1的元素有序,此时的数组就是有序的了。
为方便理解我还准备了图片:
如果还是不懂的话我还给你准备了优质的文章讲解:https://mp.weixin.qq.com/s/4kJdzLB7qO1sES2FEW0Low
代码如下
#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
int a[10010];
int XInsSort(int n) {
int cur;
//在插入排序的基础上增加了一个控制增量(gap)的循环
//最初为数组长度的一半
//下一次增量为上一个增量的一半,最终增量为1就是一组
for(int gap=n/2;gap>0;gap/=2) {//分组
for(int i=gap;i<n;i++){//对各个分组进行直接插入排序
cur=a[i];
int j=i-gap;//插入之前定义j,改变j-1
for(;(j>=0)&&(cur<a[j]);j-=gap){//j--改为 j-=gap
a[j+gap]=a[j];//改a[j+1]=a[j];
}
a[j+gap]=cur;//改a[j+1]=cur;
}
}
}
int main()
{
int n=7;
for(int i=0;i<n;i++){
cin>>a[i];
}
XInsSort(n);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}
需要注意的是,对各个分组进行插入的时候并不是先对一个组排序完了再来对另一个组排序,而是轮流对每个组进行排序。
性质:1、时间复杂度:O(nlogn) 2、空间复杂度:O(1) 3、非稳定排序 4、原地排序
一趟排序后整个数组变的部分有序了,小组内有序
5、归并排序(分治)
将一个大的无序数组有序,我们可以把大的数组分成两个,然后对这两个数组分别进行排序,之后在把这两个数组合并成一个有序的数组。由于两个小的数组都是有序的,所以在合并的时候是很快的。
通过递归的方式将大的数组一直分割,直到数组的大小为 1,此时只有一个元素,那么该数组就是有序的了,之后再把两个数组大小为1的合并成一个大小为2的,再把两个大小为2的合并成4的 ….. 直到全部小的数组合并起来。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:https://mp.weixin.qq.com/s/YNF-6vY5m2Q_kEXJbep5NQ
代码如下:
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
void Merge(int a[],int start,int mid,int end,int temp[]) {
int i=start;//左半段开始
int m=mid;//左半段结束
int j=mid+1;//右半段开始
int n=end;//右半段结束
int k=0;
//temp 临时数组存放合并结果 ,分别选取两组中小的插入temp
while(i<=m&&j<=n){
if(a[i]<a[j]){
temp[k++]=a[i++];
}
else{
temp[k++]=a[j++];
}
}
while(i<=m){
temp[k++]=a[i++];
}
while(j<=n){
temp[k++]=a[j++];
}
//左右不等的情况,数组复制
for(int i=0;i<k;i++){
a[start+i]=temp[i];
}
}
//将两个任意数组合并排序
void MergeSort(int a[],int start,int end,int temp[]) {
if(start<end){
int mid=(start+end)/2;
MergeSort(a,start,mid,temp);//递归
MergeSort(a,mid+1,end,temp);
Merge(a,start,mid,end,temp);
}
}
int main()
{
int a[1000];
int temp[1000];
int n;
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
}
MergeSort(a,0,n-1,temp);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}
性质:1、时间复杂度:O(nlogn) 2、空间复杂度:O(n) 3、稳定排序 4、非原地排序
然而面试官要你写个非递归式的归并排序怎么办?别怕,我这还撸了个非递归式的归并排序,代码如下:(暂时没修改)
1public class MergeSort {
2 // 非递归式的归并排序
3 public static int[] mergeSort(int[] arr) {
4 int n = arr.length;
5 // 子数组的大小分别为1,2,4,8...
6 // 刚开始合并的数组大小是1,接着是2,接着4....
7 for (int i = 1; i < n; i += i) {
8 //进行数组进行划分
9 int left = 0;
10 int mid = left + i - 1;
11 int right = mid + i;
12 //进行合并,对数组大小为 i 的数组进行两两合并
13 while (right < n) {
14 // 合并函数和递归式的合并函数一样
15 merge(arr, left, mid, right);
16 left = right + 1;
17 mid = left + i - 1;
18 right = mid + i;
19 }
20 // 还有一些被遗漏的数组没合并,千万别忘了
21 // 因为不可能每个字数组的大小都刚好为 i
22 if (left < n && mid < n) {
23 merge(arr, left, mid, n - 1);
24 }
25 }
26 return arr;
27 }
28}
6、快速排序
我们从数组中选择一个元素,我们把这个元素称之为中轴元素吧,然后把数组中所有小于中轴元素的元素放在其左边,所有大于或等于中轴元素的元素放在其右边,显然,此时中轴元素所处的位置的是有序的。也就是说,我们无需再移动中轴元素的位置。
从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素),接着我们通过递归的方式,让中轴元素左边的数组和右边的数组也重复同样的操作,直到数组的大小为1,此时每个元素都处于有序的位置。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:
代码如下:
#include<iostream>
using namespace std;
int QuickSort(int a[],int left,int right){
if(left<right){
int i,j,base;
i=left;//从第二数字开始
j=right;//从后向前扫描
base=a[i];//基准数据
while(i<j){
while(i<j&&a[j]>base){
j--;
}
if(i<j){
a[i++]=a[j];
}
while(i<j&&a[i]<base){
i++;
}
if(i<j){
a[j--]=a[i];
}
}
a[i]=base;//基准元素放入正确位置 ij都可以
QuickSort(a,left,i-1);
QuickSort(a,i+1,right);
}
}
int main()
{
int n;
int a[1000];
int temp[1000];
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
}
QuickSort(a,0,n-1);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}
性质:1、时间复杂度:O(nlogn) 2、空间复杂度:O(logn) 3、非稳定排序 4、原地排序
一趟排序以后基准数字放在正确位置,左边都比他小,右边都比他大,分治
7、堆排序
堆的特点就是堆顶的元素是一个最值,大顶堆的堆顶是最大值,小顶堆则是最小值。
堆排序就是把堆顶的元素与最后一个元素交换,交换之后破坏了堆的特性,我们再把堆中剩余的元素再次构成一个大顶堆,然后再把堆顶元素与最后第二个元素交换….如此往复下去,等到剩余的元素只有一个的时候,此时的数组就是有序的了。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:堆排序是什么鬼?
代码如下:
#include<iostream>
using namespace std;
void swap(int &x,int &y){
int temp;
temp=x;
x=y;
y=temp;
}
void jian(int a[],int start,int n){
while(2*start+1<n){
int MaxChild = 2 * start + 1;
if (2*start+2<n){
if(a[2*start+1]<a[2*start+2]){
MaxChild=2*start+2;
}
}
if(a[start]<a[MaxChild]) {
swap(a[start],a[MaxChild]);
start=MaxChild;
}
else{
break;
}
}
}
void HeapSort(int a[],int n){
int i=0;
for(i=n/2-1;i>=0;i--){
jian(a,i,n);
}
for(i=n;i>0;i--){
swap(a[0],a[i]);
jian(a,0,i);
}
}
int main()
{
int n;
int a[1000];
int temp[1000];
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
}
HeapSort(a,n-1);
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
return 0;
}
性质:1、时间复杂度:O(nlogn) 2、空间复杂度:O(1) 3、非稳定排序 4、原地排序
8、计数排序
计数排序是一种适合于最大值和最小值的差值不是不是很大的排序。
基本思想:就是把数组元素作为数组的下标,然后用一个临时数组统计该元素出现的次数,例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来,此时汇总起来是数据是有序的。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:什么是计数排序?
代码如下:
1public class Counting {
2 public static int[] countSort(int[] arr) {
3 if(arr == null || arr.length < 2) return arr;
4
5 int n = arr.length;
6 int max = arr[0];
7 // 寻找数组的最大值
8 for (int i = 1; i < n; i++) {
9 if(max < arr[i])
10 max = arr[i];
11 }
12 //创建大小为max的临时数组
13 int[] temp = new int[max + 1];
14 //统计元素i出现的次数
15 for (int i = 0; i < n; i++) {
16 temp[arr[i]]++;
17 }
18 int k = 0;
19 //把临时数组统计好的数据汇总到原数组
20 for (int i = 0; i <= max; i++) {
21 for (int j = temp[i]; j > 0; j--) {
22 arr[k++] = i;
23 }
24 }
25 return arr;
26 }
27}
性质:1、时间复杂度:O(n+k) 2、空间复杂度:O(k) 3、稳定排序 4、非原地排序
注:K表示临时数组的大小,下同
优化一下
上面的代码中,我们是根据 max 的大小来创建对应大小的数组,假如原数组只有10个元素,并且最小值为 min = 10000,最大值为 max = 10005,那我们创建 10005 + 1 大小的数组不是很吃亏,最大值与最小值的差值为 5,所以我们创建大小为6的临时数组就可以了。
也就是说,我们创建的临时数组大小 (max - min + 1)就可以了,然后在把 min作为偏移量。优化之后的代码如下所示:
1public class Counting {
2 public static int[] sort(int[] arr) {
3 if(arr == null || arr.length < 2) return arr;
4
5 int n = arr.length;
6 int min = arr[0];
7 int max = arr[0];
8 // 寻找数组的最大值与最小值
9 for (int i = 1; i < n; i++) {
10 if(max < arr[i])
11 max = arr[i];
12 if(min > arr[i])
13 min = arr[i];
14 }
15 int d = max - min + 1;
16 //创建大小为max的临时数组
17 int[] temp = new int[d];
18 //统计元素i出现的次数
19 for (int i = 0; i < n; i++) {
20 temp[arr[i] - min]++;
21 }
22 int k = 0;
23 //把临时数组统计好的数据汇总到原数组
24 for (int i = 0; i < d; i++) {
25 for (int j = temp[i]; j > 0; j--) {
26 arr[k++] = i + min;
27 }
28 }
29 return arr;
30 }
31}
9、桶排序
桶排序就是把最大值和最小值之间的数进行瓜分,例如分成 10 个区间,10个区间对应10个桶,我们把各元素放到对应区间的桶中去,再对每个桶中的数进行排序,可以采用归并排序,也可以采用快速排序之类的。
之后每个桶里面的数据就是有序的了,我们在进行合并汇总。
为方便理解我还准备了图片:
如果还是不懂的话我还给你准备了优质的文章讲解:什么是桶排序?
代码如下:
1public class BucketSort {
2 public static int[] BucketSort(int[] arr) {
3 if(arr == null || arr.length < 2) return arr;
4
5 int n = arr.length;
6 int max = arr[0];
7 int min = arr[0];
8 // 寻找数组的最大值与最小值
9 for (int i = 1; i < n; i++) {
10 if(min > arr[i])
11 min = arr[i];
12 if(max < arr[i])
13 max = arr[i];
14 }
15 //和优化版本的计数排序一样,弄一个大小为 min 的偏移值
16 int d = max - min;
17 //创建 d / 5 + 1 个桶,第 i 桶存放 5*i ~ 5*i+5-1范围的数
18 int bucketNum = d / 5 + 1;
19 ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(bucketNum);
20 //初始化桶
21 for (int i = 0; i < bucketNum; i++) {
22 bucketList.add(new LinkedList<Integer>());
23 }
24 //遍历原数组,将每个元素放入桶中
25 for (int i = 0; i < n; i++) {
26 bucketList.get((arr[i]-min)/d).add(arr[i] - min);
27 }
28 //对桶内的元素进行排序,我这里采用系统自带的排序工具
29 for (int i = 0; i < bucketNum; i++) {
30 Collections.sort(bucketList.get(i));
31 }
32 //把每个桶排序好的数据进行合并汇总放回原数组
33 int k = 0;
34 for (int i = 0; i < bucketNum; i++) {
35 for (Integer t : bucketList.get(i)) {
36 arr[k++] = t + min;
37 }
38 }
39 return arr;
40 }
41}
性质:1、时间复杂度:O(n+k) 2、空间复杂度:O(n+k) 3、稳定排序 4、非原地排序
注:k 表示桶的个数,下同
10、基数排序
基数排序的排序思路是这样的:先以个位数的大小来对数据进行排序,接着以十位数的大小来多数进行排序,接着以百位数的大小……
排到最后,就是一组有序的元素了。不过,他在以某位数进行排序的时候,是用“桶”来排序的。
由于某位数(个位/十位….,不是一整个数)的大小范围为0-9,所以我们需要10个桶,然后把具有相同数值的数放进同一个桶里,之后再把桶里的数按照0号桶到9号桶的顺序取出来,这样一趟下来,按照某位数的排序就完成了
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:为什么说O(n)复杂度的基数排序没有快速排序快?
代码如下:
1public class RadioSort {
2
3 public static int[] radioSort(int[] arr) {
4 if(arr == null || arr.length < 2) return arr;
5
6 int n = arr.length;
7 int max = arr[0];
8 // 找出最大值
9 for (int i = 1; i < n; i++) {
10 if(max < arr[i]) max = arr[i];
11 }
12 // 计算最大值是几位数
13 int num = 1;
14 while (max / 10 > 0) {
15 num++;
16 max = max / 10;
17 }
18 // 创建10个桶
19 ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(10);
20 //初始化桶
21 for (int i = 0; i < 10; i++) {
22 bucketList.add(new LinkedList<Integer>());
23 }
24 // 进行每一趟的排序,从个位数开始排
25 for (int i = 1; i <= num; i++) {
26 for (int j = 0; j < n; j++) {
27 // 获取每个数最后第 i 位是数组
28 int radio = (arr[j] / (int)Math.pow(10,i-1)) % 10;
29 //放进对应的桶里
30 bucketList.get(radio).add(arr[j]);
31 }
32 //合并放回原数组
33 int k = 0;
34 for (int j = 0; j < 10; j++) {
35 for (Integer t : bucketList.get(j)) {
36 arr[k++] = t;
37 }
38 //取出来合并了之后把桶清光数据
39 bucketList.get(j).clear();
40 }
41 }
42 return arr;
43 }
44}
性质:1、时间复杂度:O(kn) 2、空间复杂度:O(n+k) 3、稳定排序 4、非原地排序
7、堆排序
堆的特点就是堆顶的元素是一个最值,大顶堆的堆顶是最大值,小顶堆则是最小值。
堆排序就是把堆顶的元素与最后一个元素交换,交换之后破坏了堆的特性,我们再把堆中剩余的元素再次构成一个大顶堆,然后再把堆顶元素与最后第二个元素交换….如此往复下去,等到剩余的元素只有一个的时候,此时的数组就是有序的了。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:堆排序是什么鬼?
代码如下:
1public class Head {
2 // 堆排序
3 public static int[] headSort(int[] arr) {
4 int n = arr.length;
5 //构建大顶堆
6 for (int i = (n - 2) / 2; i >= 0; i--) {
7 downAdjust(arr, i, n - 1);
8 }
9 //进行堆排序
10 for (int i = n - 1; i >= 1; i--) {
11 // 把堆顶元素与最后一个元素交换
12 int temp = arr[i];
13 arr[i] = arr[0];
14 arr[0] = temp;
15 // 把打乱的堆进行调整,恢复堆的特性
16 downAdjust(arr, 0, i - 1);
17 }
18 return arr;
19 }
20
21 //下沉操作
22 public static void downAdjust(int[] arr, int parent, int n) {
23 //临时保存要下沉的元素
24 int temp = arr[parent];
25 //定位左孩子节点的位置
26 int child = 2 * parent + 1;
27 //开始下沉
28 while (child <= n) {
29 // 如果右孩子节点比左孩子大,则定位到右孩子
30 if(child + 1 <= n && arr[child] < arr[child + 1])
31 child++;
32 // 如果孩子节点小于或等于父节点,则下沉结束
33 if (arr[child] <= temp ) break;
34 // 父节点进行下沉
35 arr[parent] = arr[child];
36 parent = child;
37 child = 2 * parent + 1;
38 }
39 arr[parent] = temp;
40 }
41}
性质:1、时间复杂度:O(nlogn) 2、空间复杂度:O(1) 3、非稳定排序 4、原地排序
8、计数排序
计数排序是一种适合于最大值和最小值的差值不是不是很大的排序。
基本思想:就是把数组元素作为数组的下标,然后用一个临时数组统计该元素出现的次数,例如 temp[i] = m, 表示元素 i 一共出现了 m 次。最后再把临时数组统计的数据从小到大汇总起来,此时汇总起来是数据是有序的。
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:什么是计数排序?
代码如下:
1public class Counting {
2 public static int[] countSort(int[] arr) {
3 if(arr == null || arr.length < 2) return arr;
4
5 int n = arr.length;
6 int max = arr[0];
7 // 寻找数组的最大值
8 for (int i = 1; i < n; i++) {
9 if(max < arr[i])
10 max = arr[i];
11 }
12 //创建大小为max的临时数组
13 int[] temp = new int[max + 1];
14 //统计元素i出现的次数
15 for (int i = 0; i < n; i++) {
16 temp[arr[i]]++;
17 }
18 int k = 0;
19 //把临时数组统计好的数据汇总到原数组
20 for (int i = 0; i <= max; i++) {
21 for (int j = temp[i]; j > 0; j--) {
22 arr[k++] = i;
23 }
24 }
25 return arr;
26 }
27}
性质:1、时间复杂度:O(n+k) 2、空间复杂度:O(k) 3、稳定排序 4、非原地排序
注:K表示临时数组的大小,下同
优化一下
上面的代码中,我们是根据 max 的大小来创建对应大小的数组,假如原数组只有10个元素,并且最小值为 min = 10000,最大值为 max = 10005,那我们创建 10005 + 1 大小的数组不是很吃亏,最大值与最小值的差值为 5,所以我们创建大小为6的临时数组就可以了。
也就是说,我们创建的临时数组大小 (max - min + 1)就可以了,然后在把 min作为偏移量。优化之后的代码如下所示:
1public class Counting {
2 public static int[] sort(int[] arr) {
3 if(arr == null || arr.length < 2) return arr;
4
5 int n = arr.length;
6 int min = arr[0];
7 int max = arr[0];
8 // 寻找数组的最大值与最小值
9 for (int i = 1; i < n; i++) {
10 if(max < arr[i])
11 max = arr[i];
12 if(min > arr[i])
13 min = arr[i];
14 }
15 int d = max - min + 1;
16 //创建大小为max的临时数组
17 int[] temp = new int[d];
18 //统计元素i出现的次数
19 for (int i = 0; i < n; i++) {
20 temp[arr[i] - min]++;
21 }
22 int k = 0;
23 //把临时数组统计好的数据汇总到原数组
24 for (int i = 0; i < d; i++) {
25 for (int j = temp[i]; j > 0; j--) {
26 arr[k++] = i + min;
27 }
28 }
29 return arr;
30 }
31}
9、桶排序
桶排序就是把最大值和最小值之间的数进行瓜分,例如分成 10 个区间,10个区间对应10个桶,我们把各元素放到对应区间的桶中去,再对每个桶中的数进行排序,可以采用归并排序,也可以采用快速排序之类的。
之后每个桶里面的数据就是有序的了,我们在进行合并汇总。
为方便理解我还准备了图片:
如果还是不懂的话我还给你准备了优质的文章讲解:什么是桶排序?
代码如下:
1public class BucketSort {
2 public static int[] BucketSort(int[] arr) {
3 if(arr == null || arr.length < 2) return arr;
4
5 int n = arr.length;
6 int max = arr[0];
7 int min = arr[0];
8 // 寻找数组的最大值与最小值
9 for (int i = 1; i < n; i++) {
10 if(min > arr[i])
11 min = arr[i];
12 if(max < arr[i])
13 max = arr[i];
14 }
15 //和优化版本的计数排序一样,弄一个大小为 min 的偏移值
16 int d = max - min;
17 //创建 d / 5 + 1 个桶,第 i 桶存放 5*i ~ 5*i+5-1范围的数
18 int bucketNum = d / 5 + 1;
19 ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(bucketNum);
20 //初始化桶
21 for (int i = 0; i < bucketNum; i++) {
22 bucketList.add(new LinkedList<Integer>());
23 }
24 //遍历原数组,将每个元素放入桶中
25 for (int i = 0; i < n; i++) {
26 bucketList.get((arr[i]-min)/d).add(arr[i] - min);
27 }
28 //对桶内的元素进行排序,我这里采用系统自带的排序工具
29 for (int i = 0; i < bucketNum; i++) {
30 Collections.sort(bucketList.get(i));
31 }
32 //把每个桶排序好的数据进行合并汇总放回原数组
33 int k = 0;
34 for (int i = 0; i < bucketNum; i++) {
35 for (Integer t : bucketList.get(i)) {
36 arr[k++] = t + min;
37 }
38 }
39 return arr;
40 }
41}
性质:1、时间复杂度:O(n+k) 2、空间复杂度:O(n+k) 3、稳定排序 4、非原地排序
注:k 表示桶的个数,下同
10、基数排序
基数排序的排序思路是这样的:先以个位数的大小来对数据进行排序,接着以十位数的大小来多数进行排序,接着以百位数的大小……
排到最后,就是一组有序的元素了。不过,他在以某位数进行排序的时候,是用“桶”来排序的。
由于某位数(个位/十位….,不是一整个数)的大小范围为0-9,所以我们需要10个桶,然后把具有相同数值的数放进同一个桶里,之后再把桶里的数按照0号桶到9号桶的顺序取出来,这样一趟下来,按照某位数的排序就完成了
为方便理解我还准备了动图:
如果还是不懂的话我还给你准备了优质的文章讲解:为什么说O(n)复杂度的基数排序没有快速排序快?
代码如下:
1public class RadioSort {
2
3 public static int[] radioSort(int[] arr) {
4 if(arr == null || arr.length < 2) return arr;
5
6 int n = arr.length;
7 int max = arr[0];
8 // 找出最大值
9 for (int i = 1; i < n; i++) {
10 if(max < arr[i]) max = arr[i];
11 }
12 // 计算最大值是几位数
13 int num = 1;
14 while (max / 10 > 0) {
15 num++;
16 max = max / 10;
17 }
18 // 创建10个桶
19 ArrayList<LinkedList<Integer>> bucketList = new ArrayList<>(10);
20 //初始化桶
21 for (int i = 0; i < 10; i++) {
22 bucketList.add(new LinkedList<Integer>());
23 }
24 // 进行每一趟的排序,从个位数开始排
25 for (int i = 1; i <= num; i++) {
26 for (int j = 0; j < n; j++) {
27 // 获取每个数最后第 i 位是数组
28 int radio = (arr[j] / (int)Math.pow(10,i-1)) % 10;
29 //放进对应的桶里
30 bucketList.get(radio).add(arr[j]);
31 }
32 //合并放回原数组
33 int k = 0;
34 for (int j = 0; j < 10; j++) {
35 for (Integer t : bucketList.get(j)) {
36 arr[k++] = t;
37 }
38 //取出来合并了之后把桶清光数据
39 bucketList.get(j).clear();
40 }
41 }
42 return arr;
43 }
44}
性质:1、时间复杂度:O(kn) 2、空间复杂度:O(n+k) 3、稳定排序 4、非原地排序
总结
用一张图汇总了10大排序算法的性质