基数排序(俗称桶排序):
基数排序是一种全新的排序思想,不同于之前学的几种排序.
之前学的 直接插入排序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)时间复杂度的排序效率。比快排、希尔排、堆排、归并排都要优秀。
空间复杂度会比上面的排序算法高一些。