基数排序(桶排序)

基数排序(俗称桶排序):
基数排序是一种全新的排序思想,不同于之前学的几种排序.
之前学的 直接插入排序O(n^2)、希尔排序O(n^1.3 - O^2)、 冒泡排序O(n^2)、简单选择排序O(n^2)、快速排序O(nlogn)、堆排序O(nlogn)、 归并排序O(nlogn)
这些排序都是基于交换元素的排序思想,只不过有的排序算法交换的是相邻元素、有的排序算法交换的是不相邻的元素。 结论是 交换不相邻元素的排序算法要比交换相邻元素的排序算法要高效。
 
基数排序是根据多关键字 按主次实行"分配"、"收集"思想来进行排序的。 

基数排序可以基于动态数组实现也可以基于链表实现。
基于动态数组实现的基数排序：
    时间复杂度O(d*(n+n))     d为分配回收的趟数 
    空间复杂度O(n+r)
基于链表实现的基数排序:
    时间复杂度O(d*(n+r))     d为分配回收的趟数、r为桶的个数。
    空间复杂度O(n+r)         n为待排序数组转为链表存储所占用的空间,r为桶的个数。
    
关于基数排序算法的稳定性:
    只要我们保证桶中元素先进先出即可保证基数排序算法是稳定的。
    
此篇我们基于链表实现基数排序。
桶必须要具备先进先出的特性,并且由于不知道桶中元素的数量,所以桶我们采用不带头结点的队列实现。

代码展示:

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define ElemType int 
#define null NULL
/*
基数排序(俗称桶排序):
基数排序是一种全新的排序思想,不同于之前学的几种排序.
之前学的 直接插入排序O(n^2)、希尔排序O(n^1.3 - O^2)、 冒泡排序O(n^2)、简单选择排序O(n^2)、快速排序O(nlogn)、堆排序O(nlogn)、 归并排序O(nlogn)
这些排序都是基于交换元素的排序思想,只不过有的排序算法交换的是相邻元素、有的排序算法交换的是不相邻的元素。 结论是 交换不相邻元素的排序算法要比交换相邻元素的排序算法要高效。
 
基数排序是根据多关键字 按主次实行"分配"、"收集"思想来进行排序的。 

基数排序可以基于动态数组实现也可以基于链表实现。
基于动态数组实现的基数排序：
	时间复杂度O(d*(n+n))     d为分配回收的趟数 
	空间复杂度O(n+r)
基于链表实现的基数排序:
	时间复杂度O(d*(n+r))     d为分配回收的趟数、r为桶的个数。
	空间复杂度O(n+r)         n为待排序数组转为链表存储所占用的空间,r为桶的个数。
	
关于基数排序算法的稳定性:
	只要我们保证桶中元素先进先出即可保证基数排序算法是稳定的。
	
此篇我们基于链表实现基数排序。
桶必须要具备先进先出的特性,并且由于不知道桶中元素的数量,所以桶我们采用不带头结点的队列实现。 
*/ 

typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode; 
typedef struct QNode{
	struct LNode *front,*rear;
}QNode; 


//队列初始化
bool initQueue(QNode *queue){
	queue->front = null;
    queue->rear = null;
    return true;
}
//队列判空  queue->front == null || queue->rear == null 或者的判空关系也对 
bool isEmpty(QNode *queue){
	return queue->front == null && queue->rear == null;
}

//入队
bool EnQueue(QNode *queue,LNode *s){
	//入队时是第一个元素
	if(queue->rear == null){
		queue->front = s;
		queue->rear = s;
		return true;   //没这个return,最终结果也正确,但是第一个结点会在第二个结点没有入队时成环(自己指向自己) 
	}  
	//入队时不是第一个元素 
	queue->rear->next = s;
	queue->rear = s;
	return true;
}


//数组转链表,带头结点
void createLinkList(LNode *head, int a[],int n){
	for(int i = 0;i < n; i++){
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = a[i];
		s->next = null;
		head->next = s;
		head=head->next;		
	}
}
//打印单链表 
void printLinkList(LNode *head){
	
	while(head->next != null){
		printf("%d ",head->next->data);
		head=head->next;
	}
}

int main(int argc, char *argv[])
{
	int a[] = {224,321,118,611,29,305,45};
	//数组转链表  空间复杂度O(n),时间复杂度O(n) 
	LNode *head = (LNode *)malloc(sizeof(LNode));
 	createLinkList(head,a,7);
	//printLinkList(head);
	//构建桶结构 
	QNode buckets[10]; 
	//初始化桶结构 
	for(int i = 0;i < 10; i++ ){
		buckets[i].front = null;
		buckets[i].rear = null;
	}
	
	//筛选出数组中最大元素 。 --> 确定分配、回收的次数
	int max = a[0];
	for(int i = 1;i<7;i++){
		if(a[i] > max){
			max =a[i];	
		}
	}
	//找到最大元素,确定最大元素的位数
	int d = 0;
	while(max > 0){
		d++;
		max = max/10;
	}
	//分配、回收的次数 
	for( int i = 0;i < d ; i++ ){
		//先按次要关键字分配、再按主要关键字分配 
		LNode *s = head->next;
		while(s != null){
			int index = (s->data)%(int)pow(10,i+1)/(int)pow(10,i);
			EnQueue(&buckets[index],s);
			s=s->next;
		}
		
		LNode *end = head;
		for(int j = 0 ; j < 10 ; j++){
			if(!isEmpty(&buckets[j])){
				end->next = buckets[j].front;
				end = buckets[j].rear;
				//回收之后需要将桶置空 
				buckets[j].front = null;
				buckets[j].rear = null;
			}
		}
		//这个语句千万不能丢,否则链表中将出现环 
		end->next = null;
		printf("第%d次排序之后的序列是:\n",i+1);
		printLinkList(head);
		printf("\n");
		
	}
	//排好序之后,将链表中的内容复制到原数组中
	int i = 0;
	while(head->next != null){
		a[i] = head->next->data;
		i++; 
		head=head->next;
	} 
	printf("排好序之后的数组内容是\n");
	for(int i = 0;i < 7; i++){
		printf("%d ",a[i]);
	}
	printf("\n");
	
			
	return 0;
}

结果测试:

注意:

此处我们采用链式存储去实现的桶排序。将之前写过的队列代码拷贝了过来,并进行了改进。

在此种实现方式中,我们需要注意各指针的指向问题,避免环形链表的出现。并且还需要注意桶收集完成之后,我们还需要将桶置空。

空间复杂度:O(n+r) : n是链表所占用的存储空间。n个元素占用n个存储空间。r是r个桶所占用的存储空间。

时间复杂度:O(2n+d*(n+r)) : n是将n个元素分配到桶中时的时间开销。r是将n个元素从桶中收集时的时间开销，收集n个元素的时间开销为啥是O(r)而不是O(n).因为我们在收集一个桶中的所有元素时，无论桶中有多少个元素，时间复杂度都是O(1),因为我们只需要修改指针的指向即可，因此桶元素的个数即为收集时的时间开销。 d是分配收集的轮数。 2n是将数组转链表和将链表转数组的时间开销。如果数据本身就是用链表存储的,那么桶排序的时间复杂度为O(d*(n+r));

如果我们采用动态数组实现桶的话,那时间复杂度就是O(d*(n+n));桶元素收集时，由于是动态数组,我们只能一个一个的拷贝到原数组中。n个元素,拷贝工作执行n次,所以如果用动态数组实现桶，收集所有桶元素的时间复杂度就是O(n);

基数排序的适用场景:

n >> r 、d 的场景适合使用基数排序。会得到O(n)时间复杂度的排序效率。比快排、希尔排、堆排、归并排都要优秀。

空间复杂度会比上面的排序算法高一些。