排序算法

 0.1 算法分类

十种常见排序算法可以分为两大类：

• 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
• 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。 

0.2 算法复杂度

0.3 相关概念

• 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
• 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
• 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。
• 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。 

1、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 

1.1 算法描述

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

1.2 动图演示

1.3 代码实现

C++版：

#include<iostream>
using namespace std;
void bubbleSort(int arr[],int len);
int main(void){
    int arr[5] = {3,2,1,5,4};                     //raw data
    int len = sizeof(arr)/sizeof(int);            //number of data
    bubbleSort(arr,len);
    for (int i=0;i<5;i++){                        //print the data
        cout<<arr[i]<<endl;
    }
    return 0;
} 
void bubbleSort(int arr[],int len){
    for (int i=0;i<len-1;i++){                    //outer loop from[0,len-1]
        for (int j=0;j<len-i-1;j++){              //inner loop from[0,len-outerIndex-1]
            if (arr[j]>arr[j+1]){                 //if the number of former greater than the latter
                int temp = arr[j];                //exchange both numbers
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

Python版：

# -*- coding: utf-8 -*-
"""
Created on Fri May 10 13:19:14 2019

@author: Administrator
"""
def bubbleSort(arr):
    length = len(arr)
    for i in range(length-1):
        for j in range(length-1-i):
            if arr[j]>arr[j+1]:
                arr[j],arr[j+1] = arr[j+1],arr[j]
    return arr
if __name__=='__main__':
    arr = [3,2,1,5,4]
    arr = bubbleSort(arr)
    print(arr)

2、快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

2.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；可以选择最后一个元素作为基准
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

2.2 动图演示

2.3 代码实现

C++版：

#include<iostream>
#include<vector>
using namespace std;

class QuickSort{
    private:
        vector<int> list;
    public:
        QuickSort(vector<int> _list);
        int partion(int left,int right);
        void quickSort(int left,int right);        
        void swap(int i,int j);
        void out();
};
QuickSort::QuickSort(vector<int> _list){                      //initialization constructor
    int len = _list.size();
    for (int i=0;i<len;i++){
        list.push_back(_list[i]);
    }
}
int QuickSort::partion(int left,int right){
    int index = left-1;                                          //initialize index is left-1
    int x = list[right];                                      //base element is last data
    for (int i=left;i<right;i++){                              //loop from [left,right-1]
        if (list[i]<x){                                          //if small base element,then exchange data
            index++;
            swap(index,i);
        }
    }
    index++;
    list[right] = list[index];
    list[index] = x;
    return index;                                             //var index is index of base element
}
void QuickSort::quickSort(int left,int right){
    int p;
    if (left<right){
        p = partion(left,right);                            //get index of base element
        quickSort(left,p-1);                                //recursive from [left,p-1]
        quickSort(p+1,right);                                //recursive from [p+1,right]
    }
}
void QuickSort::swap(int i,int j){                            //the program of exchange data
    int temp = list[i];
    list[i] = list[j];
    list[j] = temp;
}
void QuickSort::out(){                                        //the program of print data
    for (int i=0;i<list.size();i++){
        cout<<list[i]<<endl;
    }
}
int main(void){
    vector<int> list;                                        //initialize raw data
    list.push_back(3);
    list.push_back(6);
    list.push_back(2);
    list.push_back(5);
    list.push_back(7);
    list.push_back(4);
    list.push_back(8);
    list.push_back(1);
    int len = list.size();                                    //get the numbers of raw data
    
    QuickSort quickSort(list);                                //creat object
    quickSort.quickSort(0,len-1);                            //quick sort from [0,len-1]
    quickSort.out();
    return 0;
}

python版：

# -*- coding: utf-8 -*-
"""
Created on Fri May 10 14:50:15 2019

@author: Administrator
"""
class QuickSort:    
    def partion(self,left,right):
        index = left-1                      #initialize index of base element 
        x = arr[right]                      #initialize base element
        for i in range(left,right):         #loop from [left,right-1]
            if arr[i]<x:                    #the data on the left smaller than base element
                index += 1;
                self.swap(index,i)
        index += 1
        arr[right] = arr[index]
        arr[index] = x
        return index                        #return the index of base element
    def quickSort(self,left,right):
        if left<right:
            p = self.partion(left,right)    #get the index of base element
            self.quickSort(left,p-1)        #recursive left area
            self.quickSort(p+1,right)       #recursive right area
    def swap(self,i,j):                     #the program of exchange data
        arr[i],arr[j] = arr[j],arr[i]
    def out(self):                          #the program of print data
        print(arr)

if __name__ == '__main__':
    arr = [3,6,2,5,7,4,1,8]                 #initialize rwa data
    quickSort = QuickSort()                 #initialization construtor
    quickSort.quickSort(0,len(arr)-1)       #quick sort from [0.len-1]
    quickSort.out()

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，则将当前的元素向后移动
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。

3.2 动图演示

3.2 代码实现

C++版：

#include<iostream>
using namespace std;
void insertSort(int arr[],int len){
    int temp,j;
    for (int i=1;i<len;i++){                    //outer loop from [1,len-1]
        temp = arr[i];                          //current data
        for (j=i;j>0&&temp<arr[j-1];j--){       //when current data smaller than former data
            arr[j]=arr[j-1];                    //data before and after exchange
        }
        arr[j] = temp;                          //insert temp data in suitable location
    }
}
void out(int arr[],int len){                    //the program of cout data
    for (int i=0;i<len;i++){
        cout<<arr[i]<<endl;
    }
}
int main(void){
    int arr[5] = {3,2,5,1,4};                    //initialize raw data
    int len = sizeof(arr)/sizeof(arr[0]);        //the length of raw data
    insertSort(arr,len);
    out(arr,len);
    return 0;
}

Pyhton版：

# -*- coding: utf-8 -*-
"""
Created on Fri May 10 15:20:31 2019

@author: Administrator
"""
class InsertSort:
    def insertSort(self):
        for i in range(1,len(arr)):             #outer loop from [1,len-1]
            current = arr[i]                    #cache current value
            j=i
            while j>0 and current<arr[j-1]:     #inner loop 
                arr[j]=arr[j-1]                 #data before and after exchange
                j -= 1
            arr[j] = current                    #insert current data in suitable location
    def out(self):
        print(arr)
if __name__=='__main__':
    arr = [3,2,5,1,4]                           #initialize raw data
    insertSort = InsertSort()                   #initialization constructor
    insertSort.insertSort()
    insertSort.out()

4、希尔排序（Shell Sort）

1959年Shell发明，第一个突破O(n²)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

4.1 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

• 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列个数k，对序列进行k 趟排序；
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
• 三个循环遍历，第一个是控制gap，从长度除以2开始，更新为gap=gap/2。第二个循环是从gap到最后一个元素遍历，第三个循环每隔gap个元素，如果前值小于后值，则交换。

4.2 动图演示

4.3 代码实现

C++版：

function shellSort(arr) {
    var len = arr.length;
    for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
        // 注意：这里和动图演示的不一样，动图是分组执行，实际操作是多个分组交替执行
        for (var i = gap; i < len; i++) {
            var j = i;
            var current = arr[i];
            while (j - gap >= 0 && current < arr[j - gap]) {
                 arr[j] = arr[j - gap];
                 j = j - gap;
            }
            arr[j] = current;
        }
    }
    return arr;
}

Python版：

# -*- coding: utf-8 -*-
"""
Created on Mon May 20 10:02:17 2019

@author: Administrator
"""
class ShellSort:
    def shellSort(self,arr):
        n = len(arr)                                    #length of array
        gap = n // 2                                    #initial of gap
        while gap>=1:                                   #condition of loop is gap greater than 1
            for i in range(gap,n):                      #from gap to n
                j = i
                current = arr[i]                        #cache current element
                while j-gap>=0 and current<arr[j-gap]:  #exchange by gap
                    arr[j] = arr[j-gap]                 #exchange value
                    j = j - gap
                arr[j] = current
            gap = gap // 2                              #exchange gap value
if __name__ == '__main__':
    shellSort = ShellSort()
    arr = [2,3,1,5,6,4]
    shellSort.shellSort(arr)
    print(arr)

4.4 算法分析

　　希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。

5、选择排序（Selection Sort）

　　选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 

5.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

• 初始状态：无序区为R[1..n]，有序区为空；
• 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
• n-1趟结束，数组有序化了。

5.2 动图演示

　　

5.3 代码实现

 C++版：

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
} 

python版本：

# -*- coding: utf-8 -*-
"""
Created on Mon May 20 10:39:48 2019

@author: Administrator
"""
class SelectSort:
    def selectSort(self,arr):
        n = len(arr)
        for i in range(n-1):                            #first  loop from 0 to second last
            minIndex = i                                #save minIndex is i
            for j in range(i+1,n):                      #second loop from i+1 to last one
                if arr[j] < arr[minIndex]:              #if current element small minIndex element
                    minIndex = j
            arr[minIndex],arr[i] = arr[i],arr[minIndex] #Swap the last element ordered and the current smallest element
if __name__ == '__main__':
    selectSort = SelectSort()
    arr = [3,2,4,1,6,5]
    selectSort.selectSort(arr)
    print(arr)

6、堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

6.1 算法描述

• 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
• 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
• 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

　　我认为以下几个步骤：

6.2 动图演示

6.3 代码实现

C++版：

#include<iostream>
using namespace std;
void swap(int &a,int &b){                            //交换                        
    int temp = a;
    a = b;
    b = temp;
}
void heap_build(int a[],int root,int length){        //构建堆 
    int left = root * 2 + 1;                        //左子节点 
    if (left<length){
        int flag = left;                            //一个二叉树中最大的节点缓存，初始为左节点 
        int right = left + 1;                        //根节点的右子节点下标 
        if (right < length){
            if (a[right]>a[left]){                    //比较左右节点值 
                flag = right;
            }
        }
        if (a[root]<a[flag]){                        
            swap(a[root],a[flag]);                    //使得根节点的值为三者中最大的节点 
            heap_build(a,flag,length);                 //递归进行构建堆 
        }
    }
}
void heap_sort(int a[],int length){
    for (int i=length/2;i>=0;i--){                    //从最后一个非叶子节点开始建堆 
        heap_build(a,i,length);                        //第一次，初始化堆 
    }
    for (int j=length-1;j>0;j--){                    //从倒数第二个元素开始，往前依次进行维护堆 
        swap(a[0],a[j]);                            //将堆顶与最后一个节点互换 
        heap_build(a,0,j);                            //维护堆 
    }
}
int main(void){
    int a[10] = {12,45,748,12,56,3,89,4,48,2};    
    int length = sizeof(a)/sizeof(a[0]);            //计算数组的长度 
    heap_sort(a,length);
    for (int i=0;i<length;i++){
        cout<<a[i]<<endl;
    }
    return 0;
}

python版：

# -*- coding: utf-8 -*-
"""
Created on Mon May 20 14:02:11 2019

@author: Administrator
"""

class Solution:
    def heap_build(self,a,root,length):                     
        left = root * 2 + 1                                 #index of left
        if left < length:   
            maxFlag = left                                  #initial maxflag value
            right = left+1                                  #index of right
            if right < length:
                if a[right]>a[left]:
                    maxFlag = right                         #get the max value both left and right
            if a[root]<a[maxFlag]:
                a[root],a[maxFlag] = a[maxFlag],a[root]     #get the max value of binary tree
                self.heap_build(a,maxFlag,length)           #recurvise
            
    def heap_sort(self,a,length):
        for i in range(length//2,-1,-1):                    #Build the heap from the last non-child node
            self.heap_build(a,i,length)                     #build the heap,the result is first num is biggest
        for j in range(length-1,0,-1):                      #build the heap from the last one
            a[0],a[j] = a[j],a[0]                           #swap the heap head with the last element
            self.heap_build(a,0,j)                          #build the heap from the first element
if __name__ == '__main__':
    solution = Solution()
    a = [12,45,748,12,56,3,89,4,48,2]
    solution.heap_sort(a,len(a))
    print(a)

7、归并排序（Merge Sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。 

7.1 算法描述

• 把长度为n的输入序列分成两个长度为n/2的子序列；
• 对这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

7.2 动图演示

7.3 代码实现

C++ code：（此代码有误，尚未调试成功）

#include<iostream>
using namespace std;
void merge(int a[],int left,int mid,int right){
    int left_len = mid-left+1;
    int right_len = right-mid;
    int *left_a = new int[left_len];
    int *right_a = new int[right_len];
    for (int i=0;i<left_len;i++){
        left_a[i] = a[left+i];
    }
    for (int j=0;j<right_len;j++){
        right_a[j] = a[mid+j+1];
    }
    int i,j=0;
    while(i<left_len&&j<right_len){
        if (left_a[i]<right_a[j]){
            a[left++] = left_a[i++];
        }else{
            a[left++] = right_a[j++];
            
        }
    }
    while(i<left_len){
        a[left++] = left_a[i++];
    }
    while(j<right_len){
        a[left++] = right_a[j++];
    }
    delete []left_a;
    delete []right_a; 
}
void merge_sort(int a[],int left,int right){
    if (left<right){
        int mid = (left+right)/2;
        merge_sort(a,left,mid);
        merge_sort(a,mid+1,right);
        merge(a,left,mid,right);
    }
}
int main(void){
    int a[10] = {12,45,748,13,56,3,89,4,48,2};
    int length = sizeof(a)/sizeof(a[0]);            //计算数组的长度 
    merge_sort(a,0,length-1);
    for (int i=0;i<length;i++){
        cout<<a[i]<<endl;
    }
    return 0;
} 

Python Code：

# -*- coding: utf-8 -*-
"""
Created on Mon May 20 16:19:00 2019

@author: Administrator
"""

class Solution:
    def Merge(self,left,right):                 #conquer
        result = []                             #cache result
        i = 0                                   #the index of left 
        j = 0                                   #the index of right
        while i<len(left) and j<len(right):     #condition of loop
            if left[i]<=right[j]:   
                result.append(left[i])
                i += 1
            else:
                result.append(right[j])
                j += 1
        result += left[i:]                      #The remaining number of the left array is added to the result
        result += right[j:]                     #same as above
        return result
    def Merge_sort(self,a):                     #divide
        if len(a)<=1:
            return a
        mid = len(a)//2                         #get index of mid
        left = self.Merge_sort(a[:mid])         #slice left arr
        right = self.Merge_sort(a[mid:])        #slice right arr
        return self.Merge(left,right)
if __name__ == '__main__':
    solution = Solution()
    a = [12,45,748,13,56,3,89,4,48,2]
    print("before merge_sort",a)
    result = solution.Merge_sort(a)
    print(" after merge_sort",result)

8、计数排序（Counting Sort）

计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

8.1 算法描述

• 找出待排序的数组中最大和最小的元素；
• 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
• 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
• 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

8.2 动图演示

8.3 代码实现

function countingSort(arr, maxValue) {
    var bucket = new Array(maxValue + 1),
        sortedIndex = 0;
        arrLen = arr.length,
        bucketLen = maxValue + 1;
 
    for (var i = 0; i < arrLen; i++) {
        if (!bucket[arr[i]]) {
            bucket[arr[i]] = 0;
        }
        bucket[arr[i]]++;
    }
 
    for (var j = 0; j < bucketLen; j++) {
        while(bucket[j] > 0) {
            arr[sortedIndex++] = j;
            bucket[j]--;
        }
    }
 
    return arr;
}

8.4 算法分析

计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。

9、桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。

9.1 算法描述

• 设置一个定量的数组当作空桶；
• 遍历输入数据，并且把数据一个一个放到对应的桶里去；
• 对每个不是空的桶进行排序；
• 从不是空的桶里把排好序的数据拼接起来。 

9.2 图片演示

9.3 代码实现

function bucketSort(arr, bucketSize) {
    if (arr.length === 0) {
      return arr;
    }
 
    var i;
    var minValue = arr[0];
    var maxValue = arr[0];
    for (i = 1; i < arr.length; i++) {
      if (arr[i] < minValue) {
          minValue = arr[i];                // 输入数据的最小值
      } else if (arr[i] > maxValue) {
          maxValue = arr[i];                // 输入数据的最大值
      }
    }
 
    // 桶的初始化
    var DEFAULT_BUCKET_SIZE = 5;            // 设置桶的默认数量为5
    bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
    var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;  
    var buckets = new Array(bucketCount);
    for (i = 0; i < buckets.length; i++) {
        buckets[i] = [];
    }
 
    // 利用映射函数将数据分配到各个桶中
    for (i = 0; i < arr.length; i++) {
        buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
    }
 
    arr.length = 0;
    for (i = 0; i < buckets.length; i++) {
        insertionSort(buckets[i]);                      // 对每个桶进行排序，这里使用了插入排序
        for (var j = 0; j < buckets[i].length; j++) {
            arr.push(buckets[i][j]);                     
        }
    }
 
    return arr;
}

9.4 算法分析

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

10、基数排序（Radix Sort）

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。

10.1 算法描述

• 取得数组中的最大数，并取得位数；
• arr为原始数组，从最低位开始取每个位组成radix数组；
• 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

10.2 动图演示

 

10.3 代码实现

var counter = [];
function radixSort(arr, maxDigit) {
    var mod = 10;
    var dev = 1;
    for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        for(var j = 0; j < arr.length; j++) {
            var bucket = parseInt((arr[j] % mod) / dev);
            if(counter[bucket]==null) {
                counter[bucket] = [];
            }
            counter[bucket].push(arr[j]);
        }
        var pos = 0;
        for(var j = 0; j < counter.length; j++) {
            var value = null;
            if(counter[j]!=null) {
                while ((value = counter[j].shift()) != null) {
                      arr[pos++] = value;
                }
          }
        }
    }
    return arr;
}

基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。

基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。

参考：十大经典排序