桶排序

思想：把元素均匀分成组，然后用一种排序算法对每组元素排序进行排序，最后把所有组中的元素依次加入到原数组中。

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;
}