基数排序(radix sort)属于"分配式排序"(distribution sort)，又称"桶子法"(bucket sort)或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些"桶"中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

时间效率：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。

示例代码：

package main
 
import (
    "bytes"
    "encoding/binary"	
    "fmt"
)

const digit = 4
const maxbit = -1 << 31
 

func main() {

	var data = []int32{421, 15, -175, 90, -2, 214, -52, -166}
	fmt.Println("\n--- Unsorted --- \n\n", data)
	radixsort(data)
	fmt.Println("\n--- Sorted ---\n\n", data, "\n")
} 

func radixsort(data []int32) {
    buf := bytes.NewBuffer(nil)
    ds := make([][]byte, len(data))
    for i, e := range data {
        binary.Write(buf, binary.LittleEndian, e^maxbit)
        b := make([]byte, digit)
        buf.Read(b)
        ds[i] = b
    }
    countingSort := make([][][]byte, 256)
    for i := 0; i < digit; i++ {
        for _, b := range ds {
            countingSort[b[i]] = append(countingSort[b[i]], b)
        }
        j := 0
        for k, bs := range countingSort {
            copy(ds[j:], bs)
            j += len(bs)
            countingSort[k] = bs[:0]
        }
    }   
    var w int32
    for i, b := range ds {
        buf.Write(b)
        binary.Read(buf, binary.LittleEndian, &w)
        data[i] = w^maxbit
    }   
}

输出：

--- Unsorted ---

 [421 15 -175 90 -2 214 -52 -166]

--- Sorted ---

 [-175 -166 -52 -2 15 90 214 421]