基数排序是怎么排的_基数排序详细过程

电子说

1.3w人已加入

描述

计数排序

学习基数排序之前首先学习计数排序。

计数排序假设每个元素都是在0到k之间的一个整数。

基数排序的基本思想,对于每个元素x,如果我们知道了小于x的元素的个数,就可以确定输出数组中元素x的位置,那么直接将元素x放到输出数组中。比如有3小于x的元素,那在输出数组中,x肯定位于第4个位置。

计数排序的算法用伪代码描述为:

COUNTING-SORT(A,k)

// 初始化数组C

for i=0 to k

C[i]=0

// 统计A[j]元素出现的次数,保存到C数组中

for j=0 to A.length

C[A[j]]=C[A[j]]+1

// 统计小于等于A[j]元素的个数

for k=0 to k

C[K]=C[K-1]+C[K]

// 将A中的元素放在B中正确的位置

for i=A.length to 0

B[C[A[i]]-1]=A[i]

C[A[i]]=C[A[i]]-1

注:由于有可能有相同元素存在,所以,每次将A[i]元素放入B数组中,都要将C[A[j]]的值减一,这样当遇到下一个值等于A[j]的元素时,该元素就能放在输出数组中A[j]的前面。

计数排序的详细过程如下

 

计数排序的关键代码如下

public int[] countSort(int a[], int k) {

int[] b = new int[a.length];

int[] c = new int[k];

for (int i = 0; i

c[i] = 0;

}

for (int i = 0; i

c[a[i]] += 1;

}

for (int i = 0; i

if (i != 0) {

c[i] += c[i - 1];

}

}

for (int i = a.length - 1; i >= 0; i--) {

b[c[a[i]] - 1] = a[i];

c[a[i]] = c[a[i]] - 1;

}

return b;

}

计数排序的性能

很容易得到计数排序的时间复杂度为:T(n)=O(k+n),因此当k小于等于n,也就是当k=O(n),k和n同阶时,采用计数排序的时间复杂度为T(n)=O(n)

同时,计数排序也是一种稳定的排序算法。

基数排序

基数排序最初是用在打孔卡片制表机上的一种排序算法,由Herman Hollerith发明,也就是IBM的创始人。

基数排序从最低为开始来排序的,从低位到高位,按位排序,按位排序必须是稳定的。

基数排序的详细过程

 

基数排序算法描述

RADIX-SORT(A,d)

for i=1 to d

use a stable sort to sort arrat A on digit i

在这里我们选择计数排序。考虑常规情况,对[0.。.9]之间的数排序,k=10,且一般有k<

基数排序的关键代码,这里以数组排序时按照十进制每位进行比较。

/**

* 基数排序

* @param result 最终已排序的数组,共用一个节省空间

* @param maxLen 待排序的数组中最大的位数

*/

public static void radixSort(int[] a,int[] result, int maxLen) {

int flag = 1;

// 保存每轮要排序的位对应数组a的值

int [] digitArr = new int[a.length];

for(int i=0; i

// 共比较的轮数

flag *= 10;

// b数组中对应的装着a数组中每位的数,第一轮装着各位,第二轮装着十位数。。.

for (int j = 0; j < digitArr.length; j++) {

digitArr[j]=a[j]%flag;

digitArr[j]=digitArr[j]/(flag/10);

}

countSort(a, digitArr,result,10);

// 每一轮计数排序完后刷新下一轮要排序的数组

System.arraycopy(result, 0, a, 0,result.length);

}

}

调用计数排序的函数

/**

* 计数排序 :对数组a中的元素按某些位排序

* @param tmp 要参与排序的当前位的值保存在tmp中

* @param result 每次计数排序后的新的数组顺序

*/

public static void countSort(int a[], int tmp[], int result[], int k) {

int[] c = new int[k];

for (int i = 0; i < c.length; i++) {

c[i] = 0;

}

for (int i = 0; i

c[tmp[i]] += 1;

}

for (int i = 0; i < c.length; i++) {

if (i != 0) {

c[i] += c[i - 1];

}

}

for (int i = tmp.length - 1; i >= 0; i--) {

// 和计数排序唯一的差别在于赋值的时候用真实的数据

result[c[tmp[i]] - 1] = a[i];

c[tmp[i]] = c[tmp[i]] - 1;

}

}

基数排序的性能

如果基数排序使用的稳定排序算法的时间复杂度为O(n+k),那么基数排序的时间复杂度为T(n)=O(d(n+k))

很容易理解要循环d轮,每轮耗时为O(n+k),于是总的耗时为O(d(n+k))

在此基础上,从2^r进制来看,此时k为2^r,并且一个b位数要比较b/r轮。于是我们得到T(n)=O((b/r)(n+2^r))

对上式求导可得其最小值。此时r=lgn,此时T(n)=O((b/lgn)n),如果再取b=lgn,这时就能达到最少的运行时间,时间复杂度为T(n)=O(n)

基数排序也是稳定的排序算法

打开APP阅读更多精彩内容
声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • 相关推荐

全部0条评论

快来发表一下你的评论吧 !

×
20
完善资料,
赚取积分