桶排序(BucketSort)

1 桶排序核心思想是 根据数据规模n划分 m个相同大小的区间 （每个区间为一个桶，桶可理解为容器）

2 每个桶存储区间内的元素(区间为半开区间 例如[0,10) 或者 [200,300) )

3 将n个元素按照规定范围分布到各个桶中去

4 对每个桶中的元素进行排序，排序方法可根据需要，选择快速排序，或者归并排序，或者插入排序

5 依次从每个桶中取出元素，按顺序放入到最初的输出序列中(相当于把所有的桶中的元素合并到一起)

6 桶可以通过数据结构链表实现

7 基于一个前提，待排序的n个元素大小介于0~k 之间的整数  或者是(0, 1)的浮点数也可（算法导论8.4的例子） 

8 桶排序的时间代价，假设有m个桶，则每个桶的元素为n/m

　当辅助函数为冒泡排序O(n²)  ,桶排序为 O(n)+mO((n/m)²)

   当辅助函数为快速排序时O(nlgn),  桶排序为 O(n)+mO(n/m log(n/m)) 

9 通常桶越多，执行效率越快，即省时间，但是桶越多，空间消耗就越大，是一种通过空间换时间的方式

注意：代码前部分为辅助代码

   辅助类：链表Link

辅助函数：冒泡排序BubbleSort

#include <iostream>
#include <crtdbg.h>
#include <cstring>
using namespace std;

typedef int DataType;
//建立链表
class Link
{
private:
    struct Node
    {
        DataType data;
        Node *next;
    };
    Node *head; //哨兵位
public:
    Link()
    {
        Init();
    }
    ~Link()
    {
        Delete();
    }
    void Init()
    {
        head = new Node;
        head->next = NULL;
    }
    void Delete()
    {
        for (Node *p = head; p != NULL;)
        {
            Node *pTemp = p->next;
            delete p;
            p = pTemp;
        }
        head = NULL;
    }
    void Print()
    {
        for (Node *p = head->next; p != NULL; p = p->next)
        {
            cout << p->data << endl;
        }
    }
    //顺序插入 考虑两种情况 1.空表 2.当插入值是最大值的时候
    void SortInsert(DataType data)
    {
        Node *p = head;
        do 
        {
            if (p->next == NULL || p->next->data > data)
            {
                Node *pNew = new Node;
                pNew->data = data;
                pNew->next = p->next;
                p->next = pNew;

                return;
            }
            p = p->next;
        } while (true);
    }
    //尾插法直接插入
    void Insert(DataType data)
    {
        Node *p = head;
        while(p->next != NULL)
        {
            p = p->next;
        }

        Node *pNew = new Node;
        pNew->data = data;
        pNew->next = NULL;
        p->next = pNew;
    }
    bool Empty()
    {
        return head->next == NULL;
    }
    //去掉首结点并返回首结点的值
    int ExtractDate()
    {
        if (! Empty())
        {
            DataType data = head->next->data;
            Node *p = head->next;
            Node *pFirst = p->next;

            delete p;
            p = NULL;

            head->next = pFirst; 
            return data;
        }
        return -1;
    }
};
//冒泡排序
void BubbleSort(int *a, int size)
{
    for(int i=0; i<size; ++i)
    {
        for (int j=0; j<size-1-i; ++j)
        {
            if (a[j] > a[j+1])
            {
                int tmp = a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;
            }
        }
    }
}
//基于一个前提：待排序的n个元素大小是介于 0~k 之间的整数
//array待排序数组，result辅助数组存储排序结果，k为允许的最大整数
void BucketSort(int array[], int result[], int size, int k)
{
    Link *Bucket = new Link[5];   //建立桶     
    int sectionSize = k/5;        //记录区间大小
    int index=0;            //记录区间下标

    //方法1：一般步骤
    //按照范围把array中的每个值放入相应的桶中
    for(int i=0; i<size; ++i)
    {
        index = array[i]/sectionSize;
        Bucket[index].Insert(array[i]); //为保证稳定性，链表使用了尾插法插入
    }
    //遍历每个桶，取出桶中的元素,放入辅助数组result，并排序
    int j=0 , m=0;
    for (int i=0; i<5; ++i) 
    {
        m = j; //记录已排好序的数组元素大小
        while(!Bucket[i].Empty())
        {
            result[j++] = Bucket[i].ExtractDate();    
        }

        //可根据实际情况选择快速排序，堆排序等，此处简单起见选择冒泡排序
        BubbleSort(result+m, j-m);
    }
     
    //方法2：使用链表特性，在插入链表的同时排序
    //for(int i=0; i<size; ++i)
    //{
    //    index = array[i]/sectionSize;
    //    Bucket[index].SortInsert(array[i]);
    //}
    //int j=0;
    //for(int i=0; i<5; ++i)
    //{
    //    while(!Bucket[i].Empty())
    //    {
    //        result[j++] = Bucket[i].ExtractDate();    
    //    }
    //}

    delete [] Bucket;
}

void main()
{
    //检测是否有内存泄露 需要加头文件#include <crtdbg.h>
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

    int Array[10] = {2, 6, 5, 3, 0, 7, 2, 3, 0, 3};
    int Result[10] = {0};

    BucketSort(Array, Result, sizeof(Array)/sizeof(Array[0]), 10);

    for (int i= 0 ; i < 10; ++i)
    {
        cout << Result[i] << "
";
    }

    system("pause");
}

（转载请注明作者和出处^_*  Seven++ http://www.cnblogs.com/sevenPP/  ）