C++基数排序另一种实现

Intro

这个版本的基数排序和算法导论的不太相同，思想都是一样的，但是感觉比那个好理解很多

选用unsigned int 也就是u32 作为例子，按位来，一共只有两个桶，所以要比32次。但其实基数排序非常有意思。

在于这些都是可变的

设待排序列为n个记录，d个关键码，关键码的取值范围为radix，排序时间复杂度为O(d(n+radix))，

空间复杂度2n

这里n ∈[1e6,1e9) 做了下测试，d=32(因为32bit) ，radix = 2

思路一共两条，最高位优先MSD和最低位优先LSD，都是按位分桶嘛，也就是一个从头往尾排，一个从尾往头排。两个都可以，但是MSD会有点麻烦，比完高位要是一样还得再比一下低位，要分出很多子序列。而且并没有感受到有什么特别的优点，所以就LSD了

算法流程

先设一个tmp数组，也就是桶。但是因为按位来，0和1可以是一个大桶里的两个小桶

从最低位开始，0放一桶，1放一桶，0从tmp的第0位开始装，1从最后一位装。

装完合并回data，但是注意1那个桶的顺序要弄正常一点，之前是倒着装的。

合并的时候就是0放前1放后，这样最后是升序的

讨论

编程

这个之前学排序都是用泛型写的，基数排序不是很容易泛型。如果不是unsigned , 就要对符号位单独处理。如果是浮点类型，也可以用基数排序！！！之前被人怼了，当时没学IEEE浮点标准。肯定要对尾数和阶码作特殊处理，我懒得搞了网上有论文。

但是这说明一个道理！如果想兼容之前的排序代码，就要用模板特化！

template<typename T>
void radixSort(T* data,int left,int right){}

template<> void radixSort<u32>(u32* data,int left, int right)
{
//implement
}

也就是说，对不同的typename都应该分别实现不同的方法，调用的时候会调用对应的函数。

时间复杂度与空间复杂度

O(d(n+radix))这个在intro里面提了一下，可以稍微简化一下看一下效果，忽略太小的：

O(d*n) 看着是线性的，d一般不会太大，这里的例子是32，但是快排nlgn的lgn不一定就比d大。这样分析的话，数组长度要大于1<<32之后才会看到效果。

但是，基数排序是一个比较容易并行的排序，并行之后还可以大概除一个常数(代码要写的非常好才可以把大概去掉)这就可能会比快排好啦。

实验

就是vanilla quick sort 和radix sort比。

#数组长度1e7
quick sort 1.04497
radix sort 1.65082

#数组长度1e8
quick sort 11.9672
radix sort 16.6019

#数组长度1e9
quick sort 133.076
# 爆内存啦

为什么会爆内存呢？u32是4byte，1e9个u32也就是4GB！空间复杂度2N刚好我内存是8GB。然后就只能重启了= =

这样的话是不如快排快的，改进思路就是换基数和CUDA并行

主要代码

template<typename T>
void radixSort(T* data,int left,int right){}

template<> void radixSort<u32>(u32* data,int left, int right)
{
const int len = right - left + 1;
u32* tmp = new u32[len];
for(u32 bit = 0;bit < 32;bit++)
{

u32 cnt0 = 0;
u32 cnt1 = 0;

for(u32 i = 0;i < len;i++)
{
const u32 d = data[i];
const u32 bit_mask = (1<<bit);

if(d & bit_mask)
tmp[cnt1++] = d;
else
tmp[len - cnt0++ - 1] = d;
}

for(u32 i = 0;i < cnt0;i++)
data[i] = tmp[len - i -1];
for(u32 i = 0;cnt0 < len;i++)
data[cnt0++] = tmp[i];
}
delete[] tmp;
}

全部代码

#include<thread>
#include<atomic>
#include<ctime>
#include<iostream>
#include<ctime>
#include<cstdlib>
#include<algorithm>
using namespace std;

using u32 = unsigned int;
using TYPE = u32;
const int LEN =(int)1e6;

template<typename T=int>
void disp(T* data,int l)
{
//  cout<<__func__<<": ";
for(int i = 0;i<l;i++)
{
if((i!=0) && (i%10==0))
cout<<endl;
cout<<data[i]<<" ";
}
cout<<endl;
}
template<typename T=int>
void init(T* data,int len)
{
srand(unsigned(time(0)));
for(int i = 0;i<len;i++)
data[i] = (T)rand();
}
template<typename T=int>
void bubbleSort(T* data,int left = 0,int right = LEN-1)
{
for(int i = left; i <= right; i++)
for (int j = i + 1; j <= right; j++)
if (data[i] > data[j])
swap(data[i], data[j]);
}
template<typename T=int>
void qsort(T* data,int left = 0,int right = LEN-1)
{
if(left < right)
{
int l = left;
int h = right;
T pivot = data[left];
while(l<h)
{
while(data[h] >= pivot && l < h) h--;
data[l] = data[h];
while(data[l]<pivot && l < h) l++;
data[h] = data[l];
}
data[l] = pivot;
qsort(data,left,l-1);
qsort(data,l+1,right);
}
}

bool Sorted = false;

template<typename T=int>
void sortswap(T* data,int index,int right)
{

if(index == right)
return;
if(data[index]>data[index+1])
{
swap(data[index],data[index+1]);
Sorted = false;
}
}
template<typename T=int>
void oddEvenSort(T* data,int left = 0,int right = LEN-1)
{

int latch = (right-left)/2 + (right-left)%2;
thread threads[latch];
int start = left;

while(!Sorted)
{

Sorted = true;

for(int i = start,j = 0;j<latch;i+=2,j++)
threads[j] = thread(sortswap<T>,data,i,right);

for(int i = 0;i<latch;i++)
threads[i].join();

if(start == left)
start = left +1;
else
start = left;
}
}

template<typename T>
void radixSort(T* data,int left,int right){}

template<> void radixSort<u32>(u32* data,int left, int right)
{
const int len = right - left + 1;
u32* tmp = new u32[len];
for(u32 bit = 0;bit < 32;bit++)
{

u32 cnt0 = 0;
u32 cnt1 = 0;

for(u32 i = 0;i < len;i++)
{
const u32 d = data[i];
const u32 bit_mask = (1<<bit);

if(d & bit_mask)
tmp[cnt1++] = d;
else
tmp[len - cnt0++ - 1] = d;
}

for(u32 i = 0;i < cnt0;i++)
data[i] = tmp[len - i -1];
for(u32 i = 0;cnt0 < len;i++)
data[cnt0++] = tmp[i];
}
delete[] tmp;
}

template<typename T>
void (*f[])(T*,int,int) =
{
qsort,
//bubbleSort,
//oddEvenSort,
radixSort
};
int main()
{

TYPE* data = new TYPE[LEN];
for(int i = 0;i<2;i++)
{
init<TYPE>(data,LEN);
auto t1 = clock();
f<TYPE>[i](data,0,LEN-1);
cout<<(double)(clock()-t1)/CLOCKS_PER_SEC<<endl;
//disp(data,100);
}
delete[] data;
return 0;
}