排序算法（九）：基数排序

        基数排序（Radix Sort）是一种非比较排序算法，它根据数字的每一位来对元素进行排序。它适用于排序整数或固定长度的字符串。基数排序的主要思想是从最低位（个位）开始，依次对所有元素进行排序，然后再从次低位（十位）开始，以此类推，直到最高位（或最长的字符串长度）排序完成。基数排序是一种非比较型的排序算法，它根据元素的每个位上的值进行排序。其实现步骤如下：

1. 找到待排序数组中最大的元素，根据最大元素的位数确定需要进行多少次排序。
2. 对待排序数组的每一位进行计数排序或桶排序。
3. 按照计数排序的结果重新排列待排序数组。
4. 重复步骤2和步骤3直到所有位都被处理完毕。

通过基数排序算法，可以将一组数据按照每个位上的值进行排序。

动画演示

下面为各编程语言实现计数排序的方法 

C语言

#include <stdio.h>
#include <stdlib.h>

/* 基数排序函数 */
void RadixSort(int* arr, int n){
	int max = arr[0];
	int base = 1;

	// 求数组最大值
	for (int i = 0; i < n; i++){
		if (arr[i] > max)
			max = arr[i];
	}

	// 临时存放数组元素
	int* temp = (int*)malloc(sizeof(int)*n);

	// 循环次数为最大数的位数
	while (max / base > 0){
		
		// 定义十个桶，统计每个桶内有几个数
		int bucket[10] = {0};
		for (int i = 0; i < n; i++)
			bucket[arr[i] / base % 10]++;

		// 累加桶内元素，求元素在临时数组中的位置
		for (int i = 1; i < 10; i++)
			bucket[i] += bucket[i - 1];

		// 依次把数放到临时数组
		for (int i = n - 1; i >= 0; i--){
			temp[bucket[arr[i] / base % 10] - 1] = arr[i];
			bucket[arr[i] / base % 10]--;
		}

		// 把临时数组里面的数拷贝回去
		for (int i = 0; i < n; i++)
			arr[i] = temp[i];
		base *= 10;
	}
	free(temp);
}

/* 打印数组函数 */
void PrintArray(int *arr, int n){
	for (int i = 0; i < n; i++)
		printf("%d ", arr[i]);
	putchar(10);
}

int main(){
    int i, arr[] = {4930, 4468, 7183, 326, 9928, 5391, 9401, 8300, 4277, 3542};
	int n = sizeof(arr) / sizeof(int); // 求数组长度
	
	printf("排序前的数组：");
	PrintArray(arr, n);
	
    RadixSort(arr, n);

    printf("排序后的数组：");
	PrintArray(arr, n);
	
    return 0;
}

C++

刚才C语言用了桶排序实现基数排序，下面的C++将使用计数排序实现。

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

/* 计数排序函数 */
void CountingSort(vector<int>& arr,int exp){
	int n = arr.size();
	vector<int> output(n);
	vector<int> count_arr(10, 0);
	
	// 统计每个位上的数字出现的次数
	for (int i = 0; i < n; i++)
		count_arr[(arr[i] / exp) % 10]++;
	
	// 计算每个数字在排序结果中的位置
	for (int i = 1; i < 10; i++)
		count_arr[i] += count_arr[i - 1];
	
	// 根据计数排序的结果，重新排列数组
	for (int i = n - 1; i >= 0; i--){
		output[count_arr[(arr[i] / exp) % 10] - 1] = arr[i];
		count_arr[(arr[i] / exp) % 10]--;
	}
	
	// 将排序结果复制回原数组
	for (int i = 0; i < n; i++)
		arr[i] = output[i];
}
	
/* 基数排序函数 */
void RadixSort(vector<int>& arr){
	
	// 求数组最大值
	int max = *max_element(arr.begin(), arr.end());
	
	// 对每个位计数排序
	for (int exp = 1; max / exp > 0; exp *= 10)
		CountingSort(arr, exp);
}

int main(){
	vector<int> arr = {4930, 4468, 7183, 326, 9928, 5391, 9401, 8300, 4277, 3542};
	
	cout << "排序前的数组：";
	for (int num : arr)
		cout << num << " ";

	RadixSort(arr);
	
	cout << endl << "排序后的数组：";
	for (int num : arr)
		cout << num << " ";

	return 0;
}

 Python

""" 基数排序函数 """
def RadixSort(arr):
    max_num = max(arr) # 求数组最大值
    exp = 1
    while max_num / exp > 0:
        bucket = [ [] for _ in range(10)] # 创建 10 个桶

		# 将元素放入对应桶中
        for num in arr:
            bucket[num // exp % 10].append(num)

		# 从桶中按顺序取出元素重新组成数组，然后排序更高的一位直至排序完成
        arr = [item for sublist in bucket for item in sublist]
        exp *= 10

    return arr

arr = [4930, 4468, 7183, 326, 9928, 5391, 9401, 8300, 4277, 3542]

print("排序前的数组：", ' '.join(map(str, arr)))
print("排序后的数组：", ' '.join(map(str, RadixSort(arr))))

 Java

import java.util.Arrays;

public class Radix_Sort{ 

    /* 基数排序函数 */
    public static void RadixSort(int[] arr){

        // 如果输入数组为空或长度为1，则直接返回
        if (arr == null || arr.length <= 1)
            return; 

        // 求数组最大值
        int max = Integer.MIN_VALUE; 
        for (int i = 0; i < arr.length; i++)
            max = Math.max(max, arr[i]); 

        // 计算最大值的位数，即需要进行排序的轮数
        int maxDigit = 0; 
        while (max != 0){ 
            max /= 10; 
            maxDigit++; 
        } 

        // 申请一个二维数组用于存储各个桶中的元素
        int[][] bucket = new int[10][arr.length]; 
        int[] bucketCount = new int[10]; 

        // 从最低位到最高位，依次按位排序
        for (int i = 0, n = 1; i < maxDigit; i++, n *= 10) { 

            // 将元素放入对应的桶中
            for (int j = 0; j < arr.length; j++) { 
                int digit = (arr[j] / n) % 10; 
                bucket[digit][bucketCount[digit]++] = arr[j]; 
            } 

            // 将桶中的元素依次取出，重新放回原数组
            int index = 0; 
            for (int j = 0; j < bucketCount.length; j++) { 
                if (bucketCount[j] != 0) { 
                    for (int k = 0; k < bucketCount[j]; k++)
                        arr[index++] = bucket[j][k]; 
                    bucketCount[j] = 0; 
                } 
            } 
        } 
    } 

    public static void main(String[] args) { 

        int[] arr = {4930, 4468, 7183, 326, 9928, 5391, 9401, 8300, 4277, 3542}; 

        System.out.print("排序前的数组：");
        for (int i : arr)
            System.out.print(i + " ");
        System.out.println();

        RadixSort(arr);

        System.out.print("排序后的数组：");
        for (int i : arr)
            System.out.print(i + " ");
    } 
}

至此，“排序算法”系列正式完结，感谢大家的支持！