基数排序

这个最低位优先的基数排序，非常适合移植到硬件设备中，所以，我们提供一个C源码 —————————————————————————————————————— #include <stdio.h> #include <stdlib.h> #include <string.h> #define maxSize 100 #define maxValue 20000 typedef struct { int data; int link; }SLNode; typedef struct { SLNode elem[maxSize]; int n; }StaticLinkList; void createSList(StaticLinkList *SL, int arr[], int n) { for (int i=0; i<n; i++) { SL->elem[i+1].data = arr[i]; SL->elem[i+1].link = i+2; } SL->elem[0].data = maxValue; SL->elem[0].link = 1; SL->elem[n].link = 0; SL->n = n; } #define rd 10 #define d 3 int getDigit(int x, int k) { if (k<1||k>d) { return -1; }

3 月，跳不动了？>>> 基于比较的排序最好的时间复杂度为O(N*lgN)，证明如下： 每种基于比较的排序都能够使用决策树描述其排序过程，每个节点最多有2个子节点。 该决策树的树叶的最大值即为所有可能的排序结果之和，即N的阶乘N!。 决策树的高度h即为比较的次数，因为二叉树节点数最多为2^h，所以有N! <= 2^h， 根据斯特林公式可知： h >= lgN! >= lg(N/e)^N = N*lg(N/e) = N*lgN - N*lge 因此算法复杂度最好为： O(N*lgN - N*lge) = O(N*lgN) 如果要追求效率更高的排序算法，比如线性排序，就要使用其他的非基于比较的排序算法。 本文用C实现了两种线性排序算法，分别为计数排序Counting Sort 和 基数排序 Radix Sort。这两种算法的实现要求排序元素为整数。 计数排序包括两步：计数和分配。首先对每个元素出现的次数进行计数，然后设置前缀数组得知每个元素在完成排序的数组中的位置，最后依照前缀数组进行元素分配。 可以证明，计数排序的时间复杂度为O(k+n)，其中k为元素最大值，n为元素个数。 计数排序简单实现如下： /* Counting Sort include two steps: * Countint and Distribution. */ void countingSort(int arr[

思想 基数排序，是按照元素的更小元素组成来进行排序。拿常用的数字排序举例，会先对个位进行排序，然后对十位进行排序。 其中，关键是如何对个位进行排序，如何对十位进行排序。 我们知道对于数字的每一位，只有10个数字（0-9），这就是基数。所以故名，基数排序。基数排序所以可以理解为适用于基数是有限的情况下。 所以基数排序中的基数，相当于把计数排序中的计数数组的大小确定下来了。 那么如何对个位、十位进行排序呢？可以用到计数排序。 实现 import java.util.Arrays; public class RadixSort { public static void main(String[] args) { int[] array = { 1200, 292, 121, 72, 233, 44, 12 }; radixSort(array, 10, 4); System.out.println(Arrays.toString(array)); } public static void radixSort(int[] array, int radix, int d){ int[] tempArray = new int[array.length]; int[] count = new int[radix]; int rate = 1; for (int i = 0; i < d; i+

有10个桶 每个桶的容积是待排序数组的长度 第一次将数组中的元素，以个位对应桶的序号放入桶中再依次取出。 第二次将数组中的元素，以十位对应桶的序号放入桶中再依次取出。 依此类推。 最后取出的数组为排序后的数组。 来源： CSDN 作者： weixin_zw654748898 链接： https://blog.csdn.net/weixin_45731789/article/details/104790051

基数排序 基数排序是经典的 拿空间换时间 的排序算法。当预排数据中有重复数据时，该算法排完序后，重复数据的相对顺序仍然不变，即表明基数排序是一种稳定排序算法。其基本思想如下：第一轮按每个数的个位数的顺序，将数放入0-9的10个桶中，然后按顺序取出来放回原数组；第二轮按每个数的十位数的顺序，将数放入0-9的10个桶中，然后按顺序取出来放回原数组；依次类推。 其代码步骤如下： 得到数组中最大数的位数，确定需要排几轮； 定义一个长度为10的二维数组模拟10个桶，其中每个桶的长度为原数组的长度； 定义一个一维数组用来记录每一轮的每个桶中放了多少个数据； 每一轮先按每个数个位、十位、百位.的顺序放入桶中；放完之后再按桶的顺序将每个数放回到原数组。直至排完 特别注意： 基数排序是经典的拿空间（内存）换时间的排序算法，当预排数据量过于庞大时，耗费的内存也会很大，一定要注意硬件内存是否够用，否则会出现内存不足的错误。 上述过程不满足于预排数据中有负数的情况，当预排数据中存在负数，算法步骤要进行相应调整。 每一步的详细说明已在代码中注释，如有错误，还望指出，我会及时改正。 package com.sort.radixSort; import java.util.Arrays; /* * 基数排序 */ public class RadixSortDemo1 { public static void

#include<iostream> #include<cmath> #include<queue> using namespace std; int main() { int numbers[11]={10,34,23,112,32,54,234,110,11220,9430,1234}; queue<int> que[10]; int m=0,max=numbers[0]; for(int i=1;i<11;i++){ max=numbers[i]>max?numbers[i]:max; } while(max){ max/=10; m++; } int i,j,k,t; for(i=0;i<m;i++){ for(j=0;j<11;j++){ k=(int)(numbers[j]/pow(10,i))%10; que[k].push(numbers[j]); } for(j=0,t=0;j<10;j++){ while(que[j].empty()==0){ int tmp=que[j].front(); que[j].pop(); numbers[t]=tmp; t++; } } } for(int i=0;i<11;i++) cout<<numbers[i]<<endl; } 来源： CSDN 作者： 猹弟 链接： https://blog.csdn.net

基数排序介绍（桶排序）介绍： 1） 基数排序 属于“分配式”排序，又称“桶子法”，顾名思义，它是通过键值的各个位的值，将要排序的 元素分配 至某些“桶”中，达到排序的作用； 2）基数排序法是属于稳定性的排序，基数排序法是效率高的 稳定性排序法 ； 3）基数排序是 桶排序 的拓展； 4）基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按照每个位数分别比较。 基数排序基本思想：     将所有待比较数值统一为同样的数为长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成了一个有序序列。 基数排序图文说明： 代码实现： import java . util . Arrays ; public class RadixSort { public static void main ( String args [ ] ) { int [ ] arr = { 53 , 3 , 542 , 748 , 14 , 214 } ; radixSort ( arr ) ; } public static void radixSort ( int [ ] arr ) { int max = arr [ 0 ] ; for ( int i = 1 ; i < arr . length ; i ++ )

在800万数据的时候比希尔 要快 ，比快速 ，归并要快 但是占内存空间过大，8000万，会造成堆溢出，现在写法不能比较负数 需要创建一个二维数组用于排序，一个一位数组用于下标存储。 package a; import java.util.Arrays; public class Radix { public static void main(String[] args) { int var = 8000000; // int var = 8; int [] arr = new int[var]; for (int i = 0; i < arr.length; i++) { arr[i] = (int)(Math.random()*900000000); } long be = System.currentTimeMillis(); // int [] arr = {53, 3, 542, 748, 14, 214}; radix(arr); long end = System.currentTimeMillis(); System.out.println(end-be); System.out.println("Arrays.toString(arr) = " + Arrays.toString(arr)); // int max = findmaxlength(arr); }

基数排序 定义 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。 算法描述 取得数组中的最大数，并取得位数； arr为原始数组，从最低位开始取每个位组成radix数组； 对radix进行计数排序（利用计数排序适用于小范围数的特点）； 代码实现 #基于桶排序的基数排序 def radixSort ( list ) : d = len ( str ( max ( list ) ) ) for k in range ( d ) : #d轮排序 s = [ [ ] for i in range ( 10 ) ] #因为每一位数字都是0~9，故建立10个桶 for i in list : s [ int ( i / ( 10 ** k ) % 10 ) ] . append ( i ) list = [ j for i in s for j in i ] return list nums = [ 5 , 6 , 3 , 2 , 1 , 2 , 0 , 8 , 0 , 65 ] print ( radixSort ( nums ) ) 时间复杂度 时间复杂度 最优时间复杂度：O(n*k) 最坏时间复杂度：O(n*k) 稳定性

基数排序 基数排序算法的思想很有趣，他不依靠直接比较元素排序。而是采用分配式排序,单独处理元素的每一位。从最高位向最低位处理 称为:最高位优先（MSD）反之称为:最低位优先(LSD)。基数排序也称为桶排序。下面以最低位优先为例。 原理 准备10个容器，编号0-9，对应数字0-9。 容器是有序的(按添加顺序) 然后按待排序元素的 某一位的 数字 (比如:个位/十位/白位)将其存放到对应容器中（数字相同,如: 个位是数字1时, 就把这个元素放在1号桶），所有元素这样处理完后, 再从0号容器开始依次到9号容器, 将其中的元素顺序取出。所以容器内的元素收集合并 复制回原数组 ，然后再从下一位开始…(比如个位处理完后, 再处理十位/百位....最高位) 这里假设数组元素都是3位数。从个位开始，将数组中的元素按个位数字放入对应的桶中，再从桶中顺序取出到数组，这是数组按个位数字有序排列，再以相同的逻辑处理十位和百位。最后数组中就是有序的了 这里的排序原理是:将元素按位排序, 但是优先级不同, 做高位优先级高, 然后是次高位...。这样考虑：一组元素按最高位排序，那么在不考虑其他位的情况下，这组元素是有序的。再考虑低位，当个位排序好后，在排序十位，这时对十位的排序影响个位了吗？并没有。这就是优先级（权重）的问题， 十位对数字大小的影响显然比个位高。 示例代码1 示例算法测试效率并不高