排序算法之计数&基数排序

计数排序>

   给定一组待排序的数据，找到这组数据中的最大值，然后开辟一个最大值加1的数组，用memset初始化为全0，然后再次遍历原数组，使得这个新开辟的数组中存储的是该数字出现的次数，此时只需要将新数组的内容写入原数组即可.

     


      我们发现计数排序其实利用的是哈希的思想来统计次数,是一种非比较的排序,它的时间复杂度为O(N+范围),因为计数排序是一种以空间换取时间的排序算法.

 计数排序的优化>

      如果给定这样一组数据"1001,1002,1003",那仫按照之前的思路我们就需要开辟1004块空间，很明显存在极大的空间浪费.要优化它只能从减小开辟空间的个数入手了.

      其实我们可以找出一组数据中的最大值和最小值，此时开辟的辅助数组只需要开辟max-min+1块即可，在统计次数要重新映射进辅助数组.

     

void CountSort(int *a,int size)
{
assert(a);
int max=a[0];
int min=a[0];
//找到最大最小值
for (int i=0;i<size;++i)
{
if(a[i] > max)
max=a[i];
if(a[i] < min)
min=a[i];
}
int range=max-min+1;
int *tmp=new int[range];
memset(tmp,0,sizeof(int)*range);
//统计数字出现的次数
for (int i=0;i<size;++i)
{
tmp[a[i]-min]++;
}
//还原初始数组
int index=0;
for (int i=0;i<range;++i)
{
while (tmp[i]--)
{
a[index++]=i+min;
}
}
delete[] tmp;
}

 

 

基数排序>

     基数排序是另一种非比较的排序，类似哈希桶.它的主要思想是:从低位开始将一组序列按照这一位值的大小放至相应的编号0~9中。等到低位排完之后再按照类似的想法继续排次低位，直至排到最高位为止，此时这个序列就是有序的序列.

    

int GetMaxDigit(int *a,int size)
{
//标识数量级
int base=10;
//统计最大数据的位数
int digit=1;
for (int i=0;i<size;++i)
{
while (a[i] >= base)
{
++digit;
base *= 10;
}
}
return digit;
}
void LSDSort(int *a,int size)
{
assert(a);
int base=1;
int digit=GetMaxDigit(a,size);
int *count=new int[10];
int *start=new int[10];
int *tmp=new int[size];
while(digit--)
{
//统计数字出现的次数
memset(count,0,sizeof(int)*size);
for (int i=0;i<size;++i)
{
count[(a[i]/base)%10]++;
}
//求每组数据的起始位置
start[0]=0;
for (int i=1;i<10;++i)
{
start[i]=start[i-1]+count[i-1];
}
//将数据写入tmp中
for (int i=0;i<size;++i)
{
int num=(a[i]/base)%10;
tmp[start[num]]=a[i];
start[num]++;
}
//将tmp中的内容写入a中
for (int i=0;i<size;++i)
{
a[i]=tmp[i];
}
base *= 10;
}
delete[] tmp;
}

 

  

    在上述找最大位的方法先设置数量级base=10,digit统计位数=1，遍历数组，如果存在大于等于数量级的数就更新数量级统计位数加1.当然这个方法不太好理解，另一种求位数的方法是:先遍历一遍数组找到数组中的最大值，求出最大值的位数.

   基数排序的时间复杂度为O(N*digit),digit是这组待排序数据中的最大位，它的空间复杂度为O(N),基数排序是一种稳定的排序算法.

   在这里就分享结束啦~~~