桶排序算法

桶排序算法（BucketSort）

工作的原理：将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。

代码如下：

QuickSort.c文件如下：

#include "QuickSort.h"

void QuickSort(double R[],int s,int t)//使数据最快的达到目的位置；是随机选择一个数，还是选择第一个数，
                                   //肯定选择第一个操作简单，但是效率不见得高
{
    int i, j;
    double temp;
    if(s>=t)  //只剩一个数据的时候返回
        return;
    i=s, j=t;
    temp=R[s];
    while(i!=j)
    {
        while((j>i) && (R[j]>temp))//先从后边操作的原因是可以与第一个交换，
                                   //因为第一个数已经保存在temp里了，以此类推，每次交换覆盖的都是垃圾值
        {
            j--;
        }
        if(i<j)
        {
            R[i]=R[j];
            i++;
        }
        while((i<j) && (R[i]<temp))
        {
            i++;
        }
        if(i<j)
            R[j--]=R[i];//先赋值，再自减
    }
    R[i]=temp;//R[j]=temp;也行
    QuickSort(R, s, i-1);
    QuickSort(R, i+1, t);
}

QuickSort.h文件如下：

#ifndef _QUICKSORT_H_
#define _QUICKSORT_H_

void QuickSort(double f[],int s,int t);

#endif //_QUICKSORT_H_

BucketSort.c文件如下：

/*
在随机产生的空间大小分别为
N = 10， 1000，10000，100000
排序样本取值为[0,1)，分成10个桶
*/
#include "BucketSort.h"
#include "QuickSort.h"
#include <string.h>
#include <stdlib.h>

#define BUCKET_NUM 10 //桶的数目

void BucketSort(double fArray[],int length)
{
    int i,m=0; //m表示指针偏移量
    int nSize = sizeof(*fArray)*length;
    int n[BUCKET_NUM];
    double* f[BUCKET_NUM];//定义一个指针数组

    for(i=0;i<BUCKET_NUM;i++)//申请内存，用作桶，共BUCKET_NUM
    {
        f[i] = (double*)malloc(nSize); 
    }
    for(i=0;i<BUCKET_NUM;i++)//每个桶内的元素数目，初始化为0
    {
        n[i] = 0; 
    }
     //f[0]  [0  ,0.1)一般来说都会申请成功
     //f[1]  [0.1,0.2)
     //f[2]  [0.2,0.3)
     //f[3]  [0.3,0.4)
     //f[4]  [0.4,0.5)
     //f[5]  [0.5,0.6)
     //f[6]  [0.6,0.7)
     //f[7]  [0.7,0.8)
     //f[8]  [0.8,0.9)
     //f[9]  [0.9,  1)

    for(i=0; i<length; i++)
    {
        if(0<=fArray[i] && fArray[i]<0.1)
        {
            *(f[0]+n[0])=fArray[i];
            n[0]++;
        }
        else if(0.1<=fArray[i] && fArray[i]<0.2)
        {
            f[1][n[1]]=fArray[i];
            n[1]++;
        }
        else if(0.2<=fArray[i] && fArray[i]<0.3)
        {
            f[2][n[2]]=fArray[i];
            n[2]++;
        }
        else if(0.3<=fArray[i] && fArray[i]<0.4)
        {
            f[3][n[3]]=fArray[i];
            n[3]++;
        }
        else if(0.4<=fArray[i] && fArray[i]<0.5)
        {
            f[4][n[4]]=fArray[i];
            n[4]++;
        }
        else if(0.5<=fArray[i] && fArray[i]<0.6)
        {
            f[5][n[5]]=fArray[i];
            n[5]++;
        }
        else if(0.6<=fArray[i] && fArray[i]<0.7)
        {
            f[6][n[6]]=fArray[i];
            n[6]++;
        }
        else if(0.7<=fArray[i] && fArray[i]<0.8)
        {
            f[7][n[7]]=fArray[i];
            n[7]++;
        }
        else if(0.8<=fArray[i] && fArray[i]<0.9)
        {
            f[8][n[8]]=fArray[i];
            n[8]++;
        }
        else //if(0.9<=fArray[i] && fArray[i]<1)
        {
            f[9][n[9]]=fArray[i];
            n[9]++;
        }
    }

    //桶内使用快速排序
    for(i=0;i<BUCKET_NUM;i++)
    {
        QuickSort(f[i], 0, n[i]-1);
    }

    //桶内排列好的数据复制到原数组
    for(i=0;i<BUCKET_NUM;i++)
    {
        if(n[0]>0)
        {
            memcpy(fArray+m,f[i],sizeof(*fArray)*n[i]);
            m+=n[i];
        }
    }

    //释放malloc分配的内存
    for(i=0;i<BUCKET_NUM;i++)
    {
        free(f[i]);
    }
}

BucketSort.h文件如下：

#ifndef _BUCKETSORT_H_
#define _BUCKETSORT_H_

void BucketSort(double fArray[],int length);

#endif // _BUCKETSORT_H_

Test.c文件如下：

#include "BucketSort.h"
#include <stdio.h>

int main()
{
    double fArray[] = {0.08, 0.52, 0.64, 0.25, 0.06, 0.98, 0.91, 0.36, 0.44, 0.17};//float肯定会有警告，因为0.1默认存为double型的
    int i,length;
    length = sizeof(fArray)/sizeof(*fArray);

    BucketSort(fArray,length);

    for(i=0;i<length;i++)
        printf("%f ",fArray[i]);
    return 0;
}