桶排序

void BucketSort(int* A, int length)
{
if (A == NULL || length < 1)
{
return;
}

//找到左、右临界值
int min = A[0];
int max = A[0];
for (int i = 1; i < length; ++i)
{
if (A[i] > max)
{
max = A[i];
}
else if (A[i] < min)
{
min = A[i];
}
}

//按临界值把整个区间划分成N组
int num = (max - min + 1) / 10 + 1;

//初始化桶
int** pBucket = new int*[num];
int* pBucketCount = new int[num];
for (int i = 0; i < num; ++i)
{
pBucketCount[i] = 0;
pBucket[i] = new int[length];
for (int j = 0; j < length; ++j)
{
pBucket[i][j] = 0;
}
}

//装入数据到桶
for (int i = 0; i < length; ++i)
{
int bucketId = (A[i] - min + 1) / 10;
pBucket[bucketId][ pBucketCount[bucketId] ] = A[i];
pBucketCount[bucketId]++;
}

//对每组元素用一种排序算法进行排序
for (int i = 0; i < num; ++i)
{
QuickSort(pBucket[i], 0, pBucketCount[i]-1);
}

//依次把各个组中的元素拷贝到原数组
int k = 0;
for (int bucketIndex = 0; bucketIndex < num; ++bucketIndex)
{
for (int elemIndex = 0; elemIndex < pBucketCount[bucketIndex]; ++elemIndex)
{
A[k++] = pBucket[bucketIndex][elemIndex];
}
}

delete[] pBucket;
pBucket = NULL;

delete pBucketCount;
pBucketCount = NULL;
}

void QuickSort(int *A, int startIndex, int endIndex)
{
if (startIndex < endIndex)
{
// 末尾分离
int partitionIndex = Partition(A, startIndex, endIndex);

QuickSort(A,startIndex, partitionIndex-1);
QuickSort(A, partitionIndex+1, endIndex);
}
}

int Partition(int * A, int startIndex, int endIndex)
{
int key = A[endIndex];
int recursiveIndex = startIndex-1;
for (int i = startIndex; i < endIndex; ++i)
{
if (A[i] <= key)
{
recursiveIndex += 1;
Swap(A,recursiveIndex,i);
}
}
Swap(A, recursiveIndex+1, endIndex);
return recursiveIndex+1;
}

void Swap(int* A, int lIndex, int rIndex)
{
int tmp = A[lIndex];
A[lIndex] = A[rIndex];
A[rIndex] = tmp;
}