线性时间排序

基数排序

http://blog.csdn.net/Dream_angel_Z/article/details/45251437

基数排序理论很好理解，基本思想就是：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

对于基数排序有两种方法：

最高位优先法（MSD）(Most Significant Digit first)

最低位优先法（LSD）(Least Significant Digit first)

基数排序是稳定的排序算法，它的平均时间复杂程度为：O(d(r+n))，空间复杂度为：O（rd+n）。

它的实现自己这么多年来一直没去写，今天抽了点时间出来，参考了网上的一些大神们还有书上的算法过程，专门对基数排序做了个Java代码的实现，采取的是从低位到高位的排序方式，源代码如下：

[java] view plain copy

1. package com.devin.sequence;  
2.   
3. import java.util.Arrays;  
4.   
5. /**  
6.  * 
7.  * @JavaTest 
8.  * @author  ldw  
9.  * @date    创建时间：2015年4月24日 下午7:15:47  
10.  * @version 2015年4月24日   
11.  * 
12.  */  
13. public class RadixSort {  
14.     public static void main(String[] args) {    
15.         Integer[] array = new Integer[] { 1200, 292, 121, 72, 233, 44, 12 };    
16.         radixSort(array, 10, 4);    
17.         System.out.println("排序后的数组：");    
18.         print(array);    
19.     }    
20.     
21.     /* 
22.      * 8.基数排序  稳定的排序算法   
23.      * array    代表数组 
24.      * radix    代表基数 
25.      * d        代表排序元素的位数 
26.      */  
27.     public static void radixSort(Integer []array, int radix, int d){  
28.         // 临时数组    
29.         Integer[] tempArray = new Integer[array.length];    
30.         // count用于记录待排序元素的信息,用来表示该位是i的数的个数    
31.         Integer[] count = new Integer[radix];    
32.     
33.         int rate = 1;  
34.         for (int i = 0; i < d; i++) {    
35.             //重置count数组，开始统计下一个关键字    
36.             Arrays.fill(count, 0);  
37.             //将array中的元素完全复制到tempArray数组中    
38.             System.arraycopy(array, 0, tempArray, 0, array.length);    
39.     
40.             //计算每个待排序数据的子关键字    
41.             for (int j = 0; j < array.length; j++) {    
42.                 int subKey = (tempArray[j] / rate) % radix;    
43.                 count[subKey]++;  
44.             }    
45.             //统计count数组的前j位（包含j）共有多少个数  
46.             for (int j = 1; j < radix; j++) {    
47.                 count[j] = count[j] + count[j - 1];   
48.             }    
49.             //按子关键字对指定的数据进行排序 ，因为开始是从前往后放，现在从后忘前读取，保证基数排序的稳定性  
50.             for (int m = array.length - 1; m >= 0; m--) {    
51.                 int subKey = (tempArray[m] / rate) % radix;    
52.                 array[--count[subKey]] = tempArray[m]; //插入到第--count[subKey]位，因为数组下标从0开始  
53.             }    
54.             rate *= radix;//前进一位    
55.             System.out.print("第" + (i+1) + "次：");  
56.             print(array);  
57.         }    
58.     }  
59.     //输出数组===============  
60.     public static void print(Integer[] array) {    
61.         for (int i = 0; i < array.length; i++) {    
62.             System.out.print(array[i] + "\t");    
63.         }    
64.         System.out.println();    
65.     }    
66. }  

测试结果：

[java] view plain copy

1. 第1次：1200    121 292 72  12  233 44    
2. 第2次：1200    12  121 233 44  72  292   
3. 第3次：12  44  72  121 1200    233 292   
4. 第4次：12  44  72  121 233 292 1200      
5. 排序后的数组：  
6. 12  44  72  121 233 292 1200   

原文地址： http://www.cnblogs.com/zer0Black/p/6169858.html

目录

• 比较和非比较的区别

• 计数排序

1. 计数排序适用数据范围

2. 过程分析

• 桶排序

1. 网络流传桶排序算法勘误

2. 桶排序适用数据范围

3. 过程分析

比较和非比较的区别

常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序。在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。
在冒泡排序之类的排序中，问题规模为n，又因为需要比较n次，所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中，问题规模通过分治法消减为logN次，所以时间复杂度平均O(nlogn)。
比较排序的优势是，适用于各种规模的数据，也不在乎数据的分布，都能进行排序。可以说，比较排序适用于一切需要排序的情况。

计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。
非比较排序只要确定每个元素之前的已有的元素个数即可，所有一次遍历即可解决。算法时间复杂度O(n)。
非比较排序时间复杂度底，但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

计数排序

计数排序适用数据范围

计数排序需要占用大量空间，它仅适用于数据比较集中的情况。比如 [0~100]，[10000~19999] 这样的数据。

过程分析

计数排序的基本思想是：对每一个输入的元素arr[i]，确定小于 arr[i] 的元素个数。
所以可以直接把 arr[i] 放到它输出数组中的位置上。假设有5个数小于 arr[i]，所以 arr[i] 应该放在数组的第6个位置上。

下面给出两种实现：

算法流程（1）

需要三个数组:
待排序数组 int[] arr = new int[]{4,3,6,3,5,1};
辅助计数数组 int[] help = new int[max - min + 1]; //该数组大小为待排序数组中的最大值减最小值+1
输出数组 int[] res = new int[arr.length];

1.求出待排序数组的最大值max=6， 最小值min=1
2.实例化辅助计数数组help，help数组中每个下标对应arr中的一个元素，help用来记录每个元素出现的次数
3.计算 arr 中每个元素在help中的位置 position = arr[i] - min，此时 help = [1,0,2,1,1,1]; （3出现了两次，2未出现）
4.根据 help 数组求得排序后的数组，此时 res = [1,3,3,4,5,6]

public static int[] countSort1(int[] arr){    if (arr == null || arr.length == 0) {        return null;    }        int max = Integer.MIN_VALUE;    int min = Integer.MAX_VALUE;        //找出数组中的最大最小值    for(int i = 0; i < arr.length; i++){        max = Math.max(max, arr[i]);        min = Math.min(min, arr[i]);    }        int help[] = new int[max];        //找出每个数字出现的次数    for(int i = 0; i < arr.length; i++){        int mapPos = arr[i] - min;        help[mapPos]++;    }        int index = 0;    for(int i = 0; i < help.length; i++){        while(help[i]-- > 0){            arr[index++] = i+min;        }    }        return arr;}

算法流程（2）

需要三个数组:
待排序数组 int[] arr = new int[]{4,3,6,3,5,1};
辅助计数数组 int[] help = new int[max - min + 1]; //该数组大小为待排序数组中的最大值减最小值+1
输出数组 int[] res = new int[arr.length];

1.求出待排序数组的最大值max=6， 最小值min=1
2.实例化辅助计数数组help，help用来记录每个元素之前出现的元素个数
3.计算 arr 每个数字应该在排序后数组中应该处于的位置，此时 help = [1,1,4,5,6,7];
4.根据 help 数组求得排序后的数组，此时 res = [1,3,3,4,5,6]

public static int[] countSort2(int[] arr){    int max = Integer.MIN_VALUE;    int min = Integer.MAX_VALUE;        //找出数组中的最大最小值    for(int i = 0; i < arr.length; i++){        max = Math.max(max, arr[i]);        min = Math.min(min, arr[i]);    }        int[] help = new int[max - min + 1];        //找出每个数字出现的次数    for(int i = 0; i < arr.length; i++){        int mapPos = arr[i] - min;        help[mapPos]++;    }        //计算每个数字应该在排序后数组中应该处于的位置    for(int i = 1; i < help.length; i++){        help[i] = help[i-1] + help[i];    }        //根据help数组进行排序    int [] res = new int[arr.length];    for(int i = 0; i < arr.length; i++){        int post = --help[arr[i] - min];        res[post] = arr[i];    }        return res;}

桶排序

网络流传桶排序算法勘误

网络各博文中流程的桶排序算法实际上都是计数排序，并非标准的桶排序。有问题的文章：
经典排序算法 - 桶排序Bucket sort
桶排序算法
排序算法 之 桶排序
最快最简单的排序算法：桶排序

桶排序适用数据范围

桶排序可用于最大最小值相差较大的数据情况，比如[9012,19702,39867,68957,83556,102456]。
但桶排序要求数据的分布必须均匀，否则可能导致数据都集中到一个桶中。比如[104,150,123,132,20000], 这种数据会导致前4个数都集中到同一个桶中。导致桶排序失效。

过程分析

桶排序的基本思想是：把数组 arr 划分为n个大小相同子区间（桶），每个子区间各自排序，最后合并。
计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

1.找出待排序数组中的最大值max、最小值min
2.我们使用 动态数组ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(max-min)/arr.length+1
3.遍历数组 arr，计算每个元素 arr[i] 放的桶
4.每个桶各自排序
5.遍历桶数组，把排序好的元素放进输出数组

public static void bucketSort(int[] arr){        int max = Integer.MIN_VALUE;    int min = Integer.MAX_VALUE;    for(int i = 0; i < arr.length; i++){        max = Math.max(max, arr[i]);        min = Math.min(min, arr[i]);    }        //桶数    int bucketNum = (max - min) / arr.length + 1;    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);    for(int i = 0; i < bucketNum; i++){        bucketArr.add(new ArrayList<Integer>());    }        //将每个元素放入桶    for(int i = 0; i < arr.length; i++){        int num = (arr[i] - min) / (arr.length);        bucketArr.get(num).add(arr[i]);    }        //对每个桶进行排序    for(int i = 0; i < bucketArr.size(); i++){        Collections.sort(bucketArr.get(i));    }        System.out.println(bucketArr.toString());    }