比较排序:
一、计数排序
1、基本思想
图解(假设升序):
1>找出待排序序列里的最大值max;
2>开辟一个大小为max+1的临时数组tmp ,将数组元素的所有初值赋为0;
3>遍历待排序序列,将序列中出现值作为下标,对tmp 数组的对应位置数据进行++;
4>上述操作完成后,tmp中统计了每个数据在待排序列中出现的次数;
3>最后,将tmp数组里值不为0的所有下标拷进原序列(注意同一个下标可能有多个重复值,都要进行拷贝,不能遗漏),排序就算完成。
3、计数排序的优化
从上面的例子中可以看出,3是待排序序列的最小值,在tmp数组中3 之前的位置并没有什么卵用,那么基于节省空间的角度进行考虑,我们可以开辟更小的临时数组统计次数,同样能完成排序。
比如要对1000,999,1008这三数进行排序,按照普通的方法前998个空间都被浪费掉了,所以这时候我们对它进行优化。找出要排序的这组元素中的最大值和最小值,这样就确定了这组元素的范围,然后开辟这个范围加1大小的数组,然后再将要排序的元素映射到这个新开辟的数组中就可以了。
结论:计数排序适用于数据比较集中的序列排序。
4、时间复杂度&&空间复杂度
5、代码实现
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
void PrintArray(int* a,size_t n)
{
for (size_t i = 0; i < n; ++i)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
void CountSort(int* a,size_t n)
{
//查找待排序序列的最大值
int max = a[0];
for (size_t i = 0; i < n-1; ++i)
{
if (max < a[i+1])
{
max = a[i+1];
}
}
//开辟临时数组用来统计数据出现次数
int* tmp = new int[max+1];
//对临时数组初值赋为0
memset(tmp,0,sizeof(int)*(max+1));
//统计数据出现次数
for (size_t i = 0; i < n; ++i)
{
tmp[a[i]]++;
}
//将数据考回原数组
int index = 0;
for (int i = 0; i <= max; ++i)
{
while(tmp[i]--)
{
a[index] = i;
++index;
}
}
delete []tmp;
}
//计数排序的优化
void CountSort1(int* a,size_t n)
{
//找到待排序序列的最大值和最小值
int max = a[0];
int min = a[0];
for (size_t i = 0; i < n-1; ++i)
{
if (max < a[i+1])
{
max = a[i+1];
}
if (min > a[i+1])
{
min = a[i+1];
}
}
//开辟适当空间的数组
int range = max - min + 1;
int* tmp = new int[range];
memset(tmp,0,sizeof(int)*(range));
for (size_t i = 0; i < n; ++i)
{
tmp[a[i]-min]++;
}
//将数据考回原数组
int index = 0;
for (int i = 0; i < range; ++i)
{
while(tmp[i]--)
{
a[index] = i+min;
++index;
}
}
delete []tmp;
}
void TestCountSort()
{
int a[] = {2,5,4,9,3,6,8,7,1,0};
int a1[] = {73,20,93,43,55,14,28,65,39,81};
size_t sz = sizeof(a)/sizeof(a[0]);
size_t sz1 = sizeof(a1)/sizeof(a1[0]);
CountSort(a,sz);
CountSort1(a1,sz1);
PrintArray(a,sz);
PrintArray(a1,sz1);
}
二、基数排序
1、基数排序的分类
LSD-- Least Significant Digit first(从低位向高位排)
MSD-- Most Significant Digit first(从高位向低位排)
由于原理差不多,此文只针对LSD进行分析。
2、基本思想
基数排序又称"桶子法",它从低位开始将待排序的数按照这一位的值放到相应的编号为0到9的桶中。等到低位排完之后得到一个序列,再将这个序列按照次低位的大小进入相应的桶中。以此类推,直到将所有的位都排完之后,这组数就已经有序了。
图解(假设升序):
3、算法执行步骤
1》统计待排序序列中最大的数是几位数;
2》开辟一个与原数组大小相同的临时数组tmp;
3》用一个count数组统计原数组中某一位(从个位向高位统计)相同的数据出现的次数;
4》用一个start数组计算原数组中某一位(从个位向高位计算)相同的数据出现的位置;
5》将桶中数据从小到大(由顶至底)用tmp数组收集起来;
6》循环3》4》5》直到所有位都被统计并计算过,然后用tmp收集起来;
7》将tmp数组的数据拷回原数组,排序完成。
图解:
4、时间复杂度&&空间复杂度
基数排序是一种非比较排序,它的时间复杂度是O(N*digit),其中digit是这组待排序中的最大的数的数量级。基数排序的空间复杂度就是在分配元素时,使用的桶空间,所以基数排序的空间复杂度是O(N)。它是一种稳定的排序方法。
5、代码实现
#pragma once
#include <iostream>
#include <assert.h>
using namespace std;
int GetMaxDigit(int* a,size_t n)//得到数组最大值的位数
{
int digit = 1;
int base = 10;
for (size_t i = 0; i < n; ++i)
{
//每次与几位数的最小数据(10、100、1000……)进行比较,
//优点是相同位数的数据只统计一次
while(a[i] >= base)
{
++digit;
base *= 10;
}
}
return digit;
}
void LSDSort(int* a,size_t n)
{
assert(a);
int base = 1;
int digit = GetMaxDigit(a,n);//统计位数
int* tmp = new int[n];//开辟临时数组
while(digit--)
{
int count[10] = {0};
//统计某位相同的数据出现次数
for (size_t i = 0; i < n; ++i)
{
int index = a[i]/base %10;
count[index]++;
}
int start[10] = {0};
//统计个位相同的数在数组a中出现的位置
for (size_t i = 1; i < n; ++i)
{
start[i] = count[i-1] + start[i-1];
}
memset(tmp,0,sizeof(int)*n);//为tmp数组初始化
//从桶中收集数据(从小到大)
for (size_t i = 0; i < n; ++i)
{
int index = a[i]/base %10;
tmp[start[index]++] = a[i];
}
//将数据拷回原数组
memcpy(a,tmp,sizeof(int)*n);
base *= 10;
}
delete []tmp;
}
void PrintArray(int* a,size_t n)
{
for (size_t i = 0; i < n; ++i)
{
cout<<a[i]<<" ";
}
cout<<endl;
}
void TestLDSort()
{
int a[] = {73,20,93,43,55,14,28,65,39,81};
size_t sz = sizeof(a)/sizeof(a[0]);
LSDSort(a,sz);
PrintArray(a,sz);
}