链表中基数排序

最新推荐文章于 2021-10-22 12:56:32 发布
原创 最新推荐文章于 2021-10-22 12:56:32 发布 · 2k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了如何使用链表实现基数排序算法，通过创建多个链表并按位数进行排序，逐步构建出最终的有序链表。示例代码包括单链表和双向链表两种实现方式。

于两两比较的算法，算法的运行下界为Ω（nlogN），如果想再降低时间复杂度，只能通过其他的非基于比较的方法。基数排序就是一种方法，其时间复杂度为O（N）


基数排序的过程，假设有4个数，我们用链表把他们连一起，这4个数为

321  892   538  439

第一步：我们先创建10个链表，L0~L9，然后按4个数的个位的数字，依次接到相应链表的后面

L0 

L1     321

L2     892

L3

L4

L5

L6

L7

L8    538

L9    439

第二步：按连接在链表从L0~L9的数字，我们依照先后顺序，重新生成一个新的链表  

321  892 538 439

然后根据各个数的十位数，我们重新把他们连接到各个链表后面

L0 

L1     

L2     321

L3     538   439

L4

L5

L6

L7

L8    

L9    892

第三步：按连接在链表从L0~L9的数字，我们依照先后顺序，重新生成一个新的链表  

321  538 439 892

然后根据各个数的百位数，我们重新把他们连接到各个链表后面

L0 

L1     

L2     

L3     321

L4     439

L5     538

L6

L7

L8    892

L9   

总结步：按连接在链表从L0~L9的数字，我们依照先后顺序，重新生成一个新的链表  

321  439 538 892

至此，排序结果完成



完整代码如下：

（使用单链表实现的）

[cpp]  view plain  copy
  1. #include<iostream>  
  2. using namespace std;  
  3.   
  4. typedef  struct Node  
  5. {  
  6.     int data;  
  7.     struct Node *next;  
  8. }LNode;  
  9.   
  10. void Initiate(LNode **head)  
  11. {  
  12.     (*head)=(LNode*)malloc(sizeof(LNode));  
  13.     (*head)->next=NULL;  
  14. }  
  15.   
  16. void Insert(LNode *head,int num)  
  17. {  
  18.     if(head==NULL) return;  
  19.     else  
  20.     {  
  21.         LNode *p,*q;  
  22.         q=head;  
  23.         p=(LNode *)malloc(sizeof(LNode));  
  24.         p->data=num;  
  25.         p->next=NULL;  
  26.         while(q->next!=NULL)  
  27.         {  
  28.             q=q->next;  
  29.         }  
  30.         q->next=p;  
  31.     }  
  32. }  
  33.   
  34. LNode * GetFirstNode(LNode *head)  
  35. {  
  36.     if(head->next==NULL)  return NULL;  
  37.     else  
  38.     {  
  39.         LNode *p;  
  40.         p=head->next;  
  41.         head->next=p->next;  
  42.         return p;  
  43.     }  
  44. }  
  45.   
  46. void AppendNode(LNode *head,LNode *node)  
  47. {  
  48.     if(head==NULL) return;  
  49.     else  
  50.     {  
  51.         LNode *p;  
  52.         p=head;  
  53.         while(p->next!=NULL)  
  54.         {  
  55.             p=p->next;  
  56.         }  
  57.         p->next=node;  
  58.         node->next=NULL;  
  59.     }  
  60. }  
  61.   
  62. void Total(LNode *L,LNode *head)  
  63. {  
  64.     LNode *p;  
  65.     p=L;  
  66.     while(p->next!=NULL)  
  67.     {  
  68.         p=p->next;  
  69.     }  
  70.     p->next=head->next;  
  71. }  
  72.   
  73. int Power(int a,int n)  
  74. {  
  75.     int y;  
  76.     if(n==0)  
  77.         return 1;  
  78.     else  
  79.     {  
  80.         y=Power(a,n/2);  
  81.         y=y*y;  
  82.         if(n%2==1)  
  83.             y=y*a;  
  84.     }  
  85.     return y;  
  86. }  
  87.   
  88. int GetNum(LNode *p,int i)  
  89. {  
  90.     int data=p->data;  
  91.     int a;  
  92.     i--;  
  93.     a=data/Power(10,i);  
  94.     return a%10;  
  95. }  
  96. //第二个形参表示参加排序的整数最大位数一共有count位数字  
  97. void radix_sort(LNode *head,int count)  
  98. {  
  99.     LNode *p[10],*q;  
  100.     int i,j,k;  
  101.   
  102.     for(j=1;j<=count;j++)  
  103.     {  
  104.     //十个头结点初始化  
  105.     for(i=0;i<10;i++)  
  106.     {  
  107.         Initiate(&p[i]);  
  108.     }  
  109.     //链表从头到尾扫描，并将扫描到的节点脱离链表。  
  110.     while(head->next!=NULL)  
  111.     {  
  112.         q=GetFirstNode(head);  
  113.         k=GetNum(q,j); //取得链表节点第j位的元素值k  
  114.         AppendNode(p[k],q); //将该节点连接到10个链表相应的位置  
  115.     }  
  116.     //将10个链表从0-9依次连接到head节点后面  
  117.     for(i=0;i<10;i++)  
  118.     {  
  119.         Total(head,p[i]);  
  120.     }  
  121.     }  
  122.   
  123.     for(i=0;i<10;i++)  
  124.     {  
  125.         delete(p[i]);  
  126.     }  
  127.   
  128.   
  129. }  
  130.   
  131. void printSL(LNode *head)  
  132. {  
  133.     LNode *p;  
  134.     p=head->next;  
  135.     while(p!=NULL)  
  136.     {  
  137.         cout<<p->data<<" ";  
  138.         p=p->next;  
  139.     }  
  140. }  
  141.   
  142. void main()  
  143. {  
  144.     LNode *head;  
  145.     Initiate(&head);  
  146.     Insert(head,1113);  
  147.     Insert(head,4212);  
  148.     Insert(head,1232);  
  149.     Insert(head,6533);  
  150.     Insert(head,2332);  
  151.     Insert(head,123);  
  152.     Insert(head,23);  
  153.     radix_sort(head,4); //表示参加排序的整数最大位数一共有4位数字  
  154.     printSL(head);  
  155.     system("pause");  
  156. }  


附上使用双向链表实现的代码：

[cpp]  view plain  copy
  1. #include<iostream>  
  2. #include<assert.h>  
  3. using namespace std;  
  4.   
  5. int power(int a,int n)  //使用递归,O（logn），求a的n次方  
  6. {  
  7.     int y;  
  8.     if(n==0) return 1;  
  9.     else   
  10.     {  
  11.         y=power(a,n/2);  
  12.         y=y*y;  
  13.         if(n%2!=0)  
  14.             y=a*y;  
  15.     }  
  16.     return y;  
  17. }  
  18.   
  19. typedef struct Node  
  20. {  
  21.     int key;  
  22.     struct Node * prior;  
  23.     struct Node * next;  
  24. }SLnode;  
  25.    
  26. SLnode * create(int n)  
  27. {  
  28.     SLnode *head,*p,*q;  
  29.     int i;  
  30.     if((head=(SLnode *) malloc (sizeof(SLnode)))==NULL)  
  31.     {  
  32.         cout<<"error";  
  33.         exit(0);//创建失败则退出  
  34.     }  
  35.     head->prior=head;  
  36.     head->next=head;  
  37.     q=head;  
  38.     for(i=0;i<n;i++)  
  39.     {  
  40.         p=(SLnode *) malloc (sizeof(SLnode));  
  41.         assert(p!=NULL);//使用断言  
  42.         cin>>p->key;  
  43.         p->prior=q;  
  44.         q->next=p;  
  45.         q=p;  
  46.     }  
  47.     head->prior=q;  
  48.     q->next=head;  
  49.     return head;  
  50. }  
  51.   
  52. void printSL(SLnode *head)  
  53. {  
  54.     SLnode *p;  
  55.     p=head->next;  
  56.     while(p!=head)  
  57.     {  
  58.         cout<<p->key<<"  ";  
  59.         p=p->next;  
  60.   
  61.     }  
  62. }  
  63.   
  64. SLnode * GetFirstNode(SLnode *head)  
  65. {  
  66.     SLnode *p;  
  67.     p=head->next;  
  68.     if(p!=head)  
  69.     {  
  70.         p->next->prior=p->prior;  
  71.         p->prior->next=p->next;  
  72.     }  
  73.     else p=NULL;  
  74.     return p;  
  75. }  
  76.   
  77. int get_num(SLnode *p,int i)  //得到第i个数  
  78. {  
  79.     int key=p->key,num;  
  80.     num=key/power(10,i);  
  81.     return num%10;  
  82. }  
  83.   
  84. void addNode(SLnode *head,SLnode *p)  
  85. {  
  86.     p->prior=head->prior;  
  87.     p->next=head;  
  88.     head->prior->next=p;  
  89.     head->prior=p;  
  90. }  
  91.   
  92. void append(SLnode *head,SLnode *Lhead)  
  93. {  
  94.     if(Lhead->next!=Lhead)  //这个判断条件一定要写上，  
  95.     {  
  96.     Lhead->next->prior=head->prior;  
  97.     Lhead->prior->next=head;  
  98.     head->prior->next=Lhead->next;  
  99.     head->prior=Lhead->prior;  
  100.     }  
  101. }  
  102.   
  103.   
  104. void radix_sort(SLnode *head,int n)  //实习基数排序  
  105. {  
  106.     SLnode *Lhead[10],*p;  
  107.     int i,j,k,f;  
  108.     for(i=0;i<10;i++)  
  109.     {  
  110.         Lhead[i]=(SLnode *)malloc(sizeof(SLnode));  
  111.         assert(Lhead[i]!=NULL);  
  112.     }  
  113.       
  114.     for(i=0;i<n;i++)  
  115.     {  
  116.         for(k=0;k<10;k++)  
  117.         {  
  118.             Lhead[k]->next=Lhead[k];  
  119.             Lhead[k]->prior=Lhead[k];  
  120.         }  
  121.         while(head->next!=head)  
  122.         {  
  123.         p=GetFirstNode(head);//get first Node,and delete it  
  124.         j=get_num(p,i);//得到第i个数  
  125.         addNode(Lhead[j],p);//将取得的节点连接到Lhead[j]后面  
  126.         }  
  127.   
  128.         for(f=0;f<10;f++)  
  129.           append(head,Lhead[f]);  
  130.     }  
  131.   
  132.      for(i=0;i<10;i++)//删除节点  
  133.         delete(Lhead[i]);  
  134.   
  135. }  
  136.   
  137. void main()  
  138. {  
  139.     int a,b;  
  140.     SLnode *head;  
  141.     cin>>a;  
  142.     head=create(a);  
  143.     printSL(head);  
  144.     cout<<endl;  
  145.     cout<<"weishu"<<endl; //输入所要比较的数字的位数  
  146.     cin>>b;  
  147.      radix_sort(head,b);  
  148.     printSL(head);  
  149.     system("pause");  
  150. }  
7-2 链式基数排序 (20分)
weixin_46047462的博客
11-23 4834
7-2 链式基数排序 (20分) 实现链式基数排序，待排序关键字n满足1≤n≤1000，最大关键字数位≤5。 输入样例： 第一行输入待排序个数n（1≤n≤1000）,再输入n个数(n的数位≤5)。 10 278 109 63 930 589 184 505 269 8 83 输出样例： 输出每趟分配-收集后链表中的关键字，趟数为序列中最大值的数位（如样例中930的数位为3），每行结尾有空格。 930 63 83 184 505 278 8 109 589 269 505 8 109 930 63 269
21天学习挑战赛-链式基数排序
qq_46138755的博客
08-20 544
有的逻辑关键字可以看成由若干个关键字复合而成的。例如，若关键字是数值，且其值都在0≤K≤9990≤K≤999范围内，则可把每一个十进制数字看成一个关键字，即可认为 K 由 3 个关键字(K0,K1,K2)(K0,K1,K2)组成，其中K0K^0K0是百位数，K1K^1K1是十位数，K2K^2K2是个位数；又若关键字KKK是由 5 个字母组成的单词，则可看成是由 5 个关键字(K0,K1,K2,K。
基数排序链表法
04-03
基数排序法用链表完成使用C语言适用于刚入门的学者
基数排序（采用链表）
u014309268的专栏
09-29 6954
基数排序
基数排序（链表）
物极必反否极泰来
08-29 996
#include using namespace std; typedef struct Node { int data; struct Node *next; }LNode; void Initiate(LNode **head) { (*head)=(LNode*)malloc(sizeof(LNode)); (*head)->next=NULL; } v
基于双向链表的基数排序
07-05
基数排序(radix sort)又称桶排序（bucket sort），相对于常见的比较排序，基数排序是一种分配式排序，需要将关键字拆分成数字位。并且按照数字位的值对数据项进行排序，这种方法不需要进行比较操作。 为了尽可能少的...
c++双向循环链表实现基数排序
m0_51204608的博客
05-15 322
c++双向循环链表实现基数排序 #include<iostream> using namespace std; #include<math.h> typedef struct node { int key; struct node *prior; struct node *next; }LNode; /*双循环链表是环形的，首尾相连的*/ //取下并删去双循环链表的第一个元素 template<class Type> Type *del_entry(Type
链表基数排序的存储空间效率优化.pptx
最新发布
05-28
在链表基数排序中，桶结构的选择对于优化存储空间有着至关重要的作用。优化桶结构可以从以下几个方面入手： 1. **基于哈希表的优化桶结构**： - **利用哈希函数减少散列冲突**：选择高效的哈希函数，例如MD5或SHA...
c代码-基于链表 实现的基数排序
07-16
本主题将深入探讨如何使用C语言和链表来实现基数排序。 基数排序基于数字的位数，从最低有效位（个位）开始，到最高有效位（高位）结束，逐位进行排序。由于C语言原生不支持链表操作，我们需要自定义链表结构来辅助...
链表实现基数排序的C代码解析
6. 模数运算：在基数排序中，要将数字按位分开，这通常涉及取模（%）和整除（/）的操作。 7. 代码实现：在C语言中，通过main.c文件编写的基数排序函数，要实现上述所有步骤，并确保代码的正确性与效率。 8. 位操作...
链表的应用---基数排序
Timsley的专栏
11-24 1075
本文主要介绍如何用链表实现基数排序
基数排序的链表实现！！
zgyangchong的专栏
08-24 1002
最近在看《数据结构与算法分析——C语言描述》 Mark Allen Weiss著， 冯舜玺 译。 本书第三章讲到链表的时候，提到了几个可以用链表实现的例子，其中一个就是基数排序，作者只给出了算法的说明，并没有给出源代码，正好前段时间看《 C 和指针》，就自己试着写了一下，比想象中的要难。 #include "radix_sort.h" #include #include #in
基数排序链表c语言,基数排序
weixin_29224589的博客
05-22 883
C++radix sort基数排序的实现算法完整源码(定义，实现，main函数测试)#include///forcollectionoffunctions#include///foramacrocalledassertwhichcanbeusedtoverifyassumptions#include算法学习笔记4 基数排序2021-05-16 23:30...
单链表实现基数排序
weixin_33882443的博客
11-19 383
基数排序是通过“分配”和“收集”过程来实现排序 （1）假设有欲排数据序列如下所示： 73 22 93 43 55 14 28 65 39 81 首先根据个位数的数值，在遍历数据时将它们各自分配到编号0至9的桶（个位数值与桶号一一对应）中。 分配结果（逻辑想象）如下图所示： 分配结束后。接下来将所有桶中所盛数据按照桶号由小到大（桶中由顶至底）依次重新收集串起来，得到如...
基数排序的数组/链表实现
putaoxiangqi的专栏
03-25 645
/************************************************************ *基数排序 *使用数组/链表完成 *核心代码： radixSortByArr(int arr[], int n) / radixSortByList(int arr[], int n) *使用数组实现的算法核心： res[ arr[i] ]+=1 ; //将待排序数组
链表实现选择排序和基数排序
m0_52341601的博客
10-22 357
#include <stdio.h> #include <math.h> int nodeNum = 5;//节点个数 const int radix = 10;//进制数 const int digit = 2;//最大位数 struct node *creatlist(); void print(struct node *head); void removeAll(struct node *head); struct node *selectSort(struct node.
C#用单链表实现基数排序
qq_32712279的博客
05-14 727
基数排序是基于关键字的排序，排序的原理是基于数的各个位权基数的逐一排序后归并序列得到有序数组 {100000, 98564, 45896, 4589, 1000, 789, 568, 89, 42, 3 }在这十个数据中，最大数100000一共有六位数，假设一个数组中最大数的位数是已知的，可以考虑使用基数排序。 【图片来源于网络】 下面给出代码： public class Select ...
基于链表的基数排序
wwj_bupt
03-14 923
数据结构与算法分析——c语言描述 第三章的基数排序 还是使用链表，特点是使用了基数排序的算法。去visualgo看一看算法动画什么都清楚了。代码参照了blackboy的。 link.h typedef int ElementType; #ifndef _List_H #define _List_H struct Node; typedef struct Node *PtrT
C++使用队列的链表形式实现基数排序radixsort（）
Howe Tan 浪漫的季节的博客
04-19 881
思路如下： 1、首先封装一个队列类Queue用链表形式实现，包括队列的插入元素、删除元素以及判断是否为空；这样就实现了一个队列 2、接着实现基数排序的算法流程； 3、建立数组队列用来保存基数为0~9的元素值（每个数从右向左取每一位）； 4、计算每个元素个位上是值，然后将该元素值放入个位数对应的队列中； 5、依次计算十位、百位...........；等并放入相应的队列中； 6、最后从队列...
基于链表的基数排序C语言实现
接着，需要实现基数排序的函数，该函数将遍历链表，根据键值的各个位上的数字，将链表中的元素分配到不同的桶中，每个桶代表一个位上的数字。这通常需要几个步骤来完成：首先，找出最大数以确定需要处理的位数；然后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值