桶排序算法 BucketSort

一、桶排序算法思想：

        待排序数组A[1...n]内的元素是随机分布在[0,1)区间内的的浮点数，辅助排序数组B[0....n-1]的每一个元素都连接一个链表，即每个元素就是一个桶，将A内每个元素乘以N(数组规模)取整，并以此为索引插入(插入排序)数组B的对应位置的链表中，最后将所有的非空链表依次连接起来就是排序结果。

二、操作步骤：

        1、设置一个指针数组，其每个元素代表一个空桶的首地址；

        2、将待排序数组中的各个元素放进对应的桶中，这一步很关键：

               元素与桶的映射关系：(int)(元素*n)对应桶的序号。

              （1）各元素放入对应的桶中，是按照某种机制放入，使得放入后，桶之间有序；

              （2）各元素放入的时候，采用有序插入，即链表的有序插入。

        3、将非空桶中的元素有序放入原数组中，则实现排序。

三、实现代码：

        C语言+单向链表的方式实现输入数据[0,1)的排序。

typedef struct node NODE; 

struct node 
{
	float data;
	NODE * pNext;
}; 

NODE * SLLInsertion( NODE * head, float data )
{
	NODE * temp = head;
	NODE * newNode = (NODE *)calloc(1, sizeof(NODE));
	
	newNode->data = data;
	newNode->pNext = NULL;

	while (temp->pNext != NULL)
	{
	   if (temp->pNext->data > newNode->data)
	   {
			newNode->pNext = temp->pNext;
			temp->pNext = newNode;
			return head;
	   }
       temp = temp->pNext;  
	}
	//新节点放入表尾
	temp->pNext = newNode;

	return head;
}

void BucketSort( float * num, int n)//桶排序
{
	if (n <= 1)
	{
		return ;
	}
	else
	{
		int i;
		int temp;
		NODE * bucket = (NODE *)calloc(n, sizeof(NODE));//n个桶
		NODE * head;

		for (i = 0; i < n; i++)
		{
			temp = (int)(num[i] * n);
			head = &bucket[temp];
			SLLInsertion( head, num[i]);
		}

		//将排好序的数据放回数组num[]中
		temp = 0;
		for (i = 0; i < n; i++)
		{
			head = &bucket[i];
			while( head->pNext != NULL )
			{
				num[temp] = head->pNext->data;
				temp++;
				head = head->pNext;
			}
		}
	}
}

四、性能分析：

       1、最好情况：

             共有n个桶，每个桶对应一个元素，这种情况下，不需要桶内数据的排序，把n个元素映射到各个桶中就已经有序，此时时间复杂度为O(n)。

       2、最坏情况：

            共有n个桶，但是n个元素都映射到一个桶中，则这种情况下，映射的时间复杂度O(n)，链表的顺序插入时间复杂度O(nlogn)，总的时间复杂度为O(nlogn)。

        3、平均情况：时间复杂度为O(nlogn)。

        总结： 桶排序的平均时间复杂度为线性的O(N+C)，其中C=N*(logN-logM)。如果相对于同样的N，桶数量M越大，其效率越高，最好的时间复杂度达到O(N)。当然桶排序的空间复杂度为O(N+M)，如果输入数据非常庞大，而桶的数量也非常多，则空间代价无疑是昂贵的。

五、稳定性分析：

        相等的数据会被分配到同一个桶中，同一桶中相等数据是在先进入数据的后面链接，则相等的数据的相对位置未发生变化，因此桶排序是稳定的。