桶排序

核心代码

void InsertSort(Bucket *pHead)
{
    Bucket *pFirst = NULL;
    Bucket *pSecond = NULL;
    int temp;

    assert(pHead != NULL);

    pFirst = pHead;
    pSecond = pHead->pNext;

    while(pSecond)
    {
        //有序数组最后一个
        pFirst = pSecond->pPre;
        //无序数组的第一个
        temp = pSecond->nValue;

        //将无序数组元素依次插入有序数组
        while(pFirst!=NULL && temp<pFirst->nValue)
        {
            pFirst->pNext->nValue = pFirst->nValue;
            pFirst = pFirst->pPre;
        }

        //将元素放入对应位置
        if(NULL == pFirst)
        {
            pHead->nValue = temp;
        }
        else
        {
            pFirst->pNext->nValue = temp;
        }

        pSecond = pSecond->pNext;
    }
}

void BucketSort(int arr[], int len)
{
    int nMax;
    int nMin;
    int i;
    int nTemp;
    int nCount;
    int nMaxIndex;
    int nMinIndex;
    Bucket **pBucket = NULL;
    int nIndex;
    Bucket *pTemp = NULL;
    Bucket *pDel = NULL;

    assert(arr!=NULL && len>0);

    nMax = arr[0];
    nMin = arr[0];
    //找最大值  最小值
    for(i=1; i<len; ++i)
    {
        if(arr[i] > nMax)
        {
            nMax = arr[i];
        }
        if(arr[i] < nMin)
        {
            nMin = arr[i];
        }
    }

    //计算数据位数
    nTemp = nMax;
    nCount = 0;
    while(nTemp)
    {
        nTemp /= 10;
        ++nCount;
    }

    //求被除基数
    nTemp = 1;
    while(nCount > 1)
    {
        nTemp *= 10;
        --nCount;
    }

    //拿到最高位
    nMaxIndex = nMax/nTemp%10;
    nMinIndex = nMin/nTemp%10;

    //根据最大值和最小值高位来开辟桶的个数
    pBucket = (Bucket **)malloc(sizeof(Bucket *)*(nMaxIndex-nMinIndex+1));

    //桶清空
    memset(pBucket, 0, sizeof(Bucket *)*(nMaxIndex-nMinIndex+1));

    //各元素如桶
    for(i=0; i<len; ++i)
    {
        nIndex = arr[i]/nTemp%10;

        //新节点开辟空间
        pTemp = (Bucket *)malloc(sizeof(Bucket));
        pTemp->nValue = arr[i];
        pTemp->pPre = NULL;

        //头添加
        //新来节点的下一个是原来的头
        //原来的头的前一个是新来的节点
        pTemp->pNext = pBucket[nIndex];
        if(pBucket[nIndex] != NULL)
        {
            pBucket[nIndex]->pPre = pTemp;
        }

        pBucket[nIndex] = pTemp;
    }

    //各桶内进行排序
    for(i=0; i<nMaxIndex-nMinIndex+1; ++i)
    {
        InsertSort(pBucket[nIndex]);
    }

    //桶内元素放回原数组
    nTemp = 0;
    for(i=0; i<nMaxIndex-nMinIndex+1; ++i)
    {
        pTemp = pBucket[i];
        while(pTemp)
        {
            arr[nTemp] = pTemp->nValue;
            ++nTemp;
            pTemp = pTemp->pNext;
        }
    }

    //释放空间
    for(i=0; i<nMaxIndex-nMinIndex+1; ++i)
    {
        pTemp = pBucket[i];
        while(pTemp)
        {
            pDel = pTemp;
            pTemp = pTemp->pNext;
            free(pDel);
            pDel = NULL;
        }
    }
}