我们都必须会的十大排序！！！

个人主页：Guiat
归属专栏：我讲你听

正文

1. 冒泡排序

【概念】
冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复地遍历待排序的列表，比较相邻的元素并交换它们的位置来实现排序。该算法的名称来源于较小的元素会像"气泡"一样逐渐"浮"到列表的顶端。

【图解】

【代码】

• C++

#include <iostream>

using namespace std;

template<typename T>

void bubble_sort(T a[], int length)
{
    for (int i = 0; i < length - 1; i ++) for (int j = 0; j < length - 1 - i; j ++)
        if (a[j] > a[j + 1]) swap(a[j], a[j + 1]);
}

int main()
{
	int arr[] = { 61, 17, 29, 22, 34, 60, 72, 21, 50, 1, 62 };
    int len = (int)sizeof arr / sizeof *arr;
    bubble_sort(arr, len);
    for (int i = 0; i < len; i ++) cout << arr[i] << " \n"[i == len - 1];

    float arrf[] = { 17.5, 19.1, 0.6, 1.9, 10.5, 12.4, 3.8, 19.7, 1.5, 25.4, 28.6, 4.4, 23.8, 5.4 };
    len = (float) sizeof arrf / sizeof *arrf;
    bubble_sort(arrf, len);
    for (int i = 0; i < len; i ++) cout << arrf[i] << " \n"[i == len - 1];
	
	return 0;
}

• Java

public class Main {
    public static void main(String[] args) {
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 }; bubble_sort(arr);
        for (int n : arr) System.out.print(n + " "); System.out.println();
    }
    public static void bubble_sort(int[] a) {
        for (int i = 0; i < a.length - 1; i ++) for (int j = 0; j < a.length - i - 1; j ++)
            if (a[j] > a[j + 1]) { int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t; }
    }
}

• Python

def bubble_sort(a):
    for i in range(len(a) - 1): 
        for j in range(len(a) - i - 1):
            if a[j] > a[j + 1]:
                a[j], a[j + 1] = a[j + 1], a[j]
    return a;
arr = [ 64, 34, 25, 12, 22, 11, 90 ]
print(bubble_sort(arr))

2. 选择排序

【概念】
选择排序（Selection Sort）是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处是不占用额外的内存空间。选择排序基本思想是每次从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾，直到全部数据排序完成。

【图解】

【代码】

• C++

#include <iostream>
#include <vector>

using namespace std;

template<typename T>

void selection_sort(vector<T>& a)
{
    for (int i = 0; i < a.size() - 1; i ++)
    {
        int min_idx = i;
        for (int j = i + 1; j < a.size(); j ++)
        {
            if (a[j] < a[min_idx]) min_idx = j;
        }
        swap(a[i], a[min_idx]);
    }
}

int main()
{
	vector<int> arr = { 64, 25, 12, 11 };
    selection_sort(arr);
    for (int n : arr) cout << n << ' '; cout << '\n';
	
	return 0;
}

• Java

public class Main {
    public static void main(String[] args) {
        int[] arr = { 64, 25, 12, 22 };
        selection_sort(arr);
        for (int n : arr) System.out.print(n + " "); System.out.println();
    }
    public static void selection_sort(int[] a) {
        for (int i = 0; i < a.length - 1; i ++) {
            int min_idx = i;
            for (int j = i + 1; j < a.length; j ++) {
                if (a[j] < a[min_idx]) min_idx = j;
            }
            int t = a[i]; a[i] = a[min_idx]; a[min_idx] = t;
        }
    } 
}

• Python

def selection_sort(a):
    for i in range(len(a) - 1):
        min_idx = i
        for j in range(i + 1, len(a)):
            if a[j] < a[min_idx]: min_idx = j
        a[i], a[min_idx] = a[min_idx], a[i]
    return a
arr = [64, 25, 12, 22, 11]
print(selection_sort(arr))

3. 插入排序

【概念】
插入排序（Insertion Sort）是一种简单直观的排序算法，它的工作原理类似于整理扑克牌。插入排序通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

【图解】

【代码】

• C++

#include <iostream>
#include <vector>

using namespace std;

void insertion_sort(vector<int>& a)
{
    for (int i = 1; i < a.size(); i ++)
    {
        int key = a[i], j = i - 1;
        while (j >= 0 && a[j] > key) { a[j + 1] = a[j]; j --; }
        a[j + 1] = key;
    }
}

int main()
{
    vector<int> arr = { 12, 11, 13, 5, 6 };
    insertion_sort(arr);
    for (int n : arr) cout << n << ' '; cout << '\n';

    return 0;
}

• Java

public class Main {
    public static void main(String[] args) {
        int[] a = { 12, 11, 13, 5, 6 };
        insertion_sort(a);
        for (int n : a) System.out.print(n + " "); System.out.println();
    }
    public static void insertion_sort(int[] a) {
        for (int i = 1; i < a.length; i ++) {
            int key = a[i], j = i - 1;
            while (j >= 0 && a[j] > key) {
                a[j + 1] = a[j]; j --;
            }
            a[j + 1] = key;
        }
    } 
}

• Python

def insertion_sort(a):
    for i in range (1, len(a)):
        key, j = a[i], i - 1
        while j >= 0 and a[j] > key:
            a[j + 1] = a[j]
            j -= 1
        a[j + 1] = key
    return a
a = [ 12, 11, 13, 5, 6 ]
insertion_sort(a)
print(a)

4. 希尔排序

【概念】
希尔排序（Shell Sort）是插入排序的一种改进版本，也称为缩小增量排序。它通过将待排序的数组按照一定的增量分割成多个子序列，对每个子序列进行插入排序，然后逐渐减小增量，重复上述过程，直到增量为1，此时进行最后一次插入排序，使整个数组有序。

【代码】

• C++

#include <iostream>
#include <vector>

using namespace std;

void shell_sort(vector<int>& a)
{
    int h = 1;
    while (h < a.size() / 3) h = 3 * h + 1;
    while (h)
    {
        for (int i = h; i < a.size(); i ++)
            for (int j = i; j >= h && a[j] < a[j - h]; j -= h)
                swap(a[j], a[j - h]);
        h /= 3;
    }
}

int main()
{
    vector<int> arr = { 12, 34, 54, 2, 3, 1, 23, 45, 19, 92 };
    shell_sort(arr);
    for (int n : arr) cout << n << ' '; cout << '\n';

    return 0;
}

• Java

public class Main {
    public static void main(String[] args) {
        int[] a = { 12, 34, 54, 2, 3, 1, 23, 45, 19, 92 };
        shell_sort(a);
        for (int n : a) System.out.print(n + " "); System.out.println();
    }
    public static void shell_sort(int[] a) {
        for (int step = a.length / 2; step > 0; step /= 2) {
            for (int i = step; i < a.length; i ++) {
                int t = a[i], j;
                for (j = i; j >= step && a[j - step] > t; j -= step)
                    a[j] = a[j - step];
                a[j] = t;
            }
        }
    } 
}

• Python

def shell_sort(a):
    import math
    gap = 1
    while gap < len(a) / 3: gap = 3 * gap + 1
    while gap:        
        for i in range(gap, len(a)):
            t, j = a[i], i - gap
            while j >= 0 and a[j] > t:
                a[j + gap] = a[j]; j -= gap
            a[j + gap] = t
        gap = math.floor(gap / 3)
    return a
a = [ 12, 34, 54, 2, 3, 1, 23, 45, 19, 92 ]
shell_sort(a)
print(a)

5. 归并排序

【概念】
归并排序（Merge Sort）是一种分治法的排序算法，它将一个大的数组分成两个较小的子数组，然后递归地对子数组进行排序，最后将排序好的子数组合并成一个有序的数组。

【代码】

• C++

#include <iostream>
#include <vector>

using namespace std;

void merge(vector<int>& a, int l, int mid, int r)
{
    int n1 = mid - l + 1, n2 = r - mid;
    vector<int> L(n1), R(n2);
    for (int i = 0; i < n1; i ++) L[i] = a[l + i];
    for (int i = 0; i < n2; i ++) R[i] = a[mid + i + 1];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j]) a[k] = L[i], i ++;
        else a[k] = R[j], j ++;
        k ++;
    }
    while (i < n1) { a[k] = L[i]; i ++; k ++; }
    while (j < n2) { a[k] = R[j]; j ++; k ++; }
}

void merge_sort(vector<int>& a, int l, int r)
{
    if (l < r)
    {
        int mid = (l + r) >> 1;
        merge_sort(a, l, mid); merge_sort(a, mid + 1, r); merge(a, l, mid, r);
    }
}

int main()
{
    vector<int> arr = { 12, 11, 13, 5, 6, 7 };
    merge_sort(arr, 0, arr.size() - 1);
    for (int n : arr) cout << n << ' '; cout << '\n';
    return 0;
}

• Java

public class Main {
    public static void main(String[] args) {
        int[] arr = { 12, 11, 13, 5, 6, 7 };
        merge_sort(arr, 0, arr.length - 1);
        for (int n : arr) System.out.print(n + " "); System.out.println();
    }
    public static void merge(int[] a, int l, int mid, int r) {
        int n1 = mid - l + 1, n2 = r - mid;
        int[] L = new int[n1], R = new int[n2];
        for (int i = 0; i < n1; i ++) L[i] = a[l + i];
        for (int j = 0; j < n2; j ++) R[j] = a[mid + j + 1];
        int i = 0, j = 0, k = l;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) { a[k] = L[i]; i ++; }
            else { a[k] = R[j]; j ++; }
            k ++;
        }
        while (i < n1) { a[k] = L[i]; i ++; k ++; }
        while (j < n2) { a[k] = R[j]; j ++; k ++; }
    }
    public static void merge_sort(int[] a, int l, int r) {
        if (l < r) {
            int mid = (l + r) >> 1;
            merge_sort(a, l, mid); merge_sort(a, mid + 1, r); merge(a, l, mid, r);
        }
    }
}

• Python

def merge(a, l, mid, r):
    n1 = mid - l + 1; n2 = r - mid
    L = [0] * n1; R = [0] * n2
    for i in range(n1): L[i] = a[l + i]
    for j in range(n2): R[j] = a[mid + j + 1]
    i = j = 0; k = l
    while i < n1 and j < n2:
        if L[i] <= R[j]: a[k] = L[i]; i += 1
        else: a[k] = R[j]; j += 1
        k += 1
    while i < n1: a[k] = L[i]; i += 1; k += 1
    while j < n2: a[k] = R[j]; j += 1; k += 1
def merge_sort(a, l = 0, r = None):
    if r is None: r = len(a) - 1
    if l < r:
        mid = l + (r - l) // 2
        merge_sort(a, l, mid)
        merge_sort(a, mid + 1, r)
        merge(a, l, mid, r)
    return 
arr = [12, 11, 13, 5, 6, 7]
print("排序前：", arr)
merge_sort(arr)
print("排序后：", arr)

6. 快速排序

【概念】
快速排序（Quick Sort）是一种分治法的排序算法，它选择一个元素作为基准（pivot），将数组分为两部分，一部分所有元素都小于基准，另一部分所有元素都大于基准，然后递归地对这两部分进行排序。

【图解】

【代码】

• C++

#include <iostream>
#include <vector>

using namespace std;

// 标准分割函数
int partition(vector<int>& a, int low, int high)
{
    int pivot = a[low];
    while (low < high)
    {
        while (low < high && a[high] >= pivot) -- high;
        a[low] = a[high];
        while (low < high && a[low] <= pivot) ++ low;
        a[high] = a[low];
    }
    a[low] = pivot;
    return low;
}

void quickSort(vector<int>& a, int low, int high)
{
    if (low < high)
    {
        int pivot = partition(a, low, high);
        quickSort(a, low, pivot - 1); quickSort(a, pivot + 1, high);
    }
}

int main()
{
    vector<int> arr = { 10, 7, 8, 9, 1, 5 };
    quickSort(arr, 0, arr.size() - 1);
    for (int n : arr) cout << n << ' '; cout << '\n';

    return 0;
}

• Java

import java.util.Arrays;

public class Main {
    private static int partition(int[] a, int low, int high) {
        int pivot = a[low];
        while (low < high) {
            while (low < high && a[high] >= pivot) -- high;
            a[low] = a[high];
            while (low < high && a[low] <= pivot) ++ low;
            a[high] = a[low];
        }
        a[low] = pivot;
        return low;
    }
    private static void quickSort(int[] a, int low, int high) {
        if (low < high) {
            int pivot = partition(a, low, high);
            quickSort(a, low, pivot - 1);
            quickSort(a, pivot + 1, high);
        }
    }
    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
}

• Python

def partition(a, low, high):
    pivot = a[low]
    while low < high:
        while low < high and a[high] >= pivot:
            high -= 1
        a[low] = a[high]
        while low < high and a[low] <= pivot:
            low += 1
        a[high] = a[low]
    a[low] = pivot
    return low
def quick_sort(a, low, high):
    if low < high:
        pivot = partition(a, low, high)
        quick_sort(a, low, pivot - 1)
        quick_sort(a, pivot + 1, high)
if __name__ == "__main__":
    arr = [10, 7, 8, 9, 1, 5]
    quick_sort(arr, 0, len(arr) - 1)
    print(arr)

7. 堆排序

【概念】
堆排序（Heap Sort）是利用堆这种数据结构进行排序的算法。堆是一个近似完全二叉树的结构，并且满足堆积的性质：即子节点的键值或索引总是小于（或者大于）它的父节点。堆排序的基本思想是将待排序的数组构建成一个大顶堆（或小顶堆），然后将堆顶元素与末尾元素交换，此时末尾元素为最大值（或最小值），然后将剩余的 n-1 个元素重新构建成一个堆，重复上述过程，直到整个数组有序。

【图解】

【代码】

• C++

#include <iostream>
#include <vector>

using namespace std;

void heapify(vector<int>& a, int n, int root)
{
    int max = root, l = 2 * root + 1, r = 2 * root + 2;
    if (l < n && a[l] > a[max]) max = l;
    if (r < n && a[r] > a[max]) max = r;
    if (max != root) { swap(a[root], a[max]); heapify(a, n, max); }
}

void heapSort(vector<int>& a)
{
    for (int i = a.size() / 2 - 1; i >= 0; i --) heapify(a, a.size(), i);
    for (int i = a.size() - 1; i > 0; i --) swap(a[0], a[i]), heapify(a, i, 0);
}

int main()
{
    vector<int> arr = { 12, 11, 13, 7, 5, 6 };
    heapSort(arr);
    for (int n : arr) cout << n << ' '; cout << '\n';

    return 0;
}

• Java

public class Main {
    public static void heapify(int[] a, int n, int root) {
        int max = root, l = 2 * root + 1, r = 2 * root + 2;
        if (l < n && a[l] > a[max]) max = l;
        if (r < n && a[r] > a[max]) max = r;
        if (max != root) {
            int temp = a[root];
            a[root] = a[max];
            a[max] = temp;
            heapify(a, n, max);
        }
    }
    public static void heapSort(int[] a) {
        int n = a.length;
        for (int i = n / 2 - 1; i >= 0; i--) heapify(a, n, i);
        for (int i = n - 1; i > 0; i--) {
            int temp = a[0];
            a[0] = a[i];
            a[i] = temp;
            heapify(a, i, 0);
        }
    }
    public static void main(String[] args) {
        int[] arr = { 12, 11, 13, 7, 5, 6 };
        heapSort(arr);
        for (int num : arr) System.out.print(num + " "); System.out.println();
    }
}

• Python

def heapify(a, n, root):
    max_idx = root
    l = 2 * root + 1
    r = 2 * root + 2
    if l < n and a[l] > a[max_idx]: max_idx = l
    if r < n and a[r] > a[max_idx]: max_idx = r
    if max_idx != root:
        a[root], a[max_idx] = a[max_idx], a[root]
        heapify(a, n, max_idx)
def heap_sort(a):
    n = len(a)
    for i in range(n // 2 - 1, -1, -1): heapify(a, n, i)
    for i in range(n - 1, 0, -1):
        a[0], a[i] = a[i], a[0]
        heapify(a, i, 0)
arr = [12, 11, 13, 7, 5, 6]
heap_sort(arr)
print(' '.join(map(str, arr)))

8. 计数排序

【概念】
计数排序（Counting Sort）是一种非比较型整数排序算法，它的工作原理是确定要排序的数组中每个元素出现的次数，然后根据元素的出现次数来确定它们在排序后数组中的位置。

【图解】

【代码】

• C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> countingSort(vector<int>& arr)
{
    if (arr.size() <= 1) return arr;
    int max = *max_element(arr.begin(), arr.end());
    int min = *min_element(arr.begin(), arr.end());
    int range = max - min + 1;
    vector<int> count(range, 0);
    for (int i = 0; i < arr.size(); i ++) count[arr[i] - min] ++;
    for (int i = 1; i < range; i ++) count[i] += count[i - 1];
    vector<int> output(arr.size());
    for (int i = arr.size() - 1; i >= 0; i --)
    {
        output[count[arr[i] - min] - 1] = arr[i];
        count[arr[i] - min] --;
    }
    for (int i = 0; i < arr.size(); i++) arr[i] = output[i];
    return arr;
}

int main()
{
    vector<int> arr = { 2, 1, 3, 11, 10, 9 };
    countingSort(arr);
    for (int n : arr) cout << n << ' '; cout << '\n';
    
    return 0;
}

• Java

import java.util.*;

public class Main {
    public static int[] countingSort(int[] arr) {
        if (arr.length <= 1) return arr;
        int max = Arrays.stream(arr).max().getAsInt();
        int min = Arrays.stream(arr).min().getAsInt();
        int range = max - min + 1;
        int[] count = new int[range];
        for (int i = 0; i < arr.length; i ++) count[arr[i] - min] ++;
        for (int i = 1; i < range; i ++) count[i] += count[i - 1];
        int[] output = new int[arr.length];
        for (int i = arr.length - 1; i >= 0; i --) {
            output[count[arr[i] - min] - 1] = arr[i];
            count[arr[i] - min] --;
        }
        return output;
    }
    public static void main(String[] args) {
        int[] arr = { 2, 1, 3, 11, 10, 9 };
        arr = countingSort(arr);
        for (int n : arr) System.out.print(n + " "); System.out.println();
    }
}

• Python

def counting_sort(arr):
    if len(arr) <= 1: return arr
    max_val = max(arr)
    min_val = min(arr)
    range_val = max_val - min_val + 1
    count = [0] * range_val
    for num in arr: count[num - min_val] += 1
    for i in range(1, range_val): count[i] += count[i - 1]
    output = [0] * len(arr)
    for i in range(len(arr) - 1, -1, -1):
        output[count[arr[i] - min_val] - 1] = arr[i]
        count[arr[i] - min_val] -= 1
    return output
arr = [ 2, 1, 3, 11, 10, 9 ]
arr = counting_sort(arr)
print(' '.join(map(str, arr)))

9. 桶排序

【概念】
桶排序（Bucket Sort）是一种分布式排序算法，它将数组分到有限数量的桶里，每个桶再分别排序（可以使用别的排序算法或者递归地使用桶排序），最后将各个桶中的元素有序地合并起来。

【代码】

• C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

vector<double> bucketSort(vector<double>& arr)
{
    if (arr.size() <= 1) return arr;
    int bucketCount = arr.size();
    vector<vector<double>> buckets(bucketCount);
    double max = *max_element(arr.begin(), arr.end());
    double min = *min_element(arr.begin(), arr.end());
    double range = (max - min) / bucketCount;
    for (double item : arr)
    {
        int bucketIndex = (int)((item - min) / range);
        if (bucketIndex == bucketCount) bucketIndex --;
        buckets[bucketIndex].push_back(item);
    }
    for (auto& bucket : buckets) sort(bucket.begin(), bucket.end());
    int index = 0;
    for (const auto& bucket : buckets) for (double item : bucket) arr[index ++] = item;
    return arr;
}

int main()
{
    vector<double> arr = { 0.42, 0.32, 0.33, 0.52, 0.37, 0.47, 0.51 };
    bucketSort(arr);
    for (double n : arr) cout << n << ' '; cout << '\n';
    
    return 0;
}

• Java

import java.util.*;

public class Main {
    public static double[] bucketSort(double[] arr) {
        if (arr.length <= 1) return arr;
        int bucketCount = arr.length;
        List<List<Double>> buckets = new ArrayList<>(bucketCount);
        for (int i = 0; i < bucketCount; i ++) buckets.add(new ArrayList<>());
        double max = arr[0];
        double min = arr[0];
        for (double num : arr) {
            if (num > max) max = num;
            if (num < min) min = num;
        }
        double range = (max - min) / bucketCount;
        for (double num : arr) {
            int bucketIndex = (int) ((num - min) / range);
            if (bucketIndex == bucketCount) bucketIndex --;
            buckets.get(bucketIndex).add(num);
        }
        for (List<Double> bucket : buckets) Collections.sort(bucket);
        int index = 0;
        for (List<Double> bucket : buckets) for (double num : bucket) arr[index++] = num;
        return arr;
    }
    public static void main(String[] args) {
        double[] arr = {0.42, 0.32, 0.33, 0.52, 0.37, 0.47, 0.51};
        bucketSort(arr);
        for (double num : arr) System.out.print(num + " "); System.out.println();
    }
}

• Python

def bucket_sort(arr):
    if len(arr) <= 1: return arr
    bucket_count = len(arr)
    buckets = [[] for _ in range(bucket_count)]
    max_val = max(arr)
    min_val = min(arr)
    range_val = (max_val - min_val) / bucket_count
    for num in arr:
        bucket_index = int((num - min_val) / range_val)
        if bucket_index == bucket_count: bucket_index -= 1
        buckets[bucket_index].append(num)
    for bucket in buckets: bucket.sort()
    index = 0
    for bucket in buckets:
        for num in bucket:
            arr[index] = num
            index += 1
    return arr
arr = [0.42, 0.32, 0.33, 0.52, 0.37, 0.47, 0.51]
bucket_sort(arr)
print(' '.join(map(str, arr)))

10. 基数排序

【概念】
基数排序（Radix Sort）是一种非比较型整数排序算法，它按照数字的位数进行排序，从最低位开始，依次对每一位进行排序（可以使用计数排序等稳定排序算法），直到最高位排序完成，整个数组也就变得有序。

【图解】

【代码】

• C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

void countingSortByDigit(vector<int>& arr, int exp)
{
    int n = arr.size(); vector<int> output(n), count(10, 0);
    for (int i = 0; i < n; i ++) count[(arr[i] / exp) % 10] ++;
    for (int i = 1; i < 10; i ++) count[i] += count[i - 1];
    for (int i = n - 1; i >= 0; i --)
    {
        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
        count[(arr[i] / exp) % 10] --;
    }
    for (int i = 0; i < n; i ++) arr[i] = output[i];
}

void radixSort(vector<int>& arr)
{
    if (arr.size() <= 1) return ;
    int max = *max_element(arr.begin(), arr.end());
    for (int exp = 1; max / exp > 0; exp *= 10) countingSortByDigit(arr, exp);
}

int main()
{
    vector<int> arr = { 170, 45, 75, 90, 802, 24, 2, 66 };
    radixSort(arr);
    for (int n : arr) cout << n << ' '; cout << '\n';

    return 0;
}

• Java

import java.util.Arrays;

public class Main {
    public static void countingSortByDigit(int[] arr, int exp) {
        int n = arr.length; int[] output = new int[n], count = new int[10];
        for (int i = 0; i < n; i ++) count[(arr[i] / exp) % 10] ++;
        for (int i = 1; i < 10; i ++) count[i] += count[i - 1];
        for (int i = n - 1; i >= 0; i --) {
            output[count[(arr[i] / exp) % 10] - 1] = arr[i];
            count[(arr[i] / exp) % 10] --;
        }
        for (int i = 0; i < n; i ++) arr[i] = output[i];
    }
    public static void radixSort(int[] arr) {
        if (arr.length <= 1) return ;
        int max = Arrays.stream(arr).max().getAsInt();
        for (int exp = 1; max / exp > 0; exp *= 10) countingSortByDigit(arr, exp);
    }
    public static void main(String[] args) {
        int[] arr = { 170, 45, 75, 90, 802, 24, 2, 66 };
        radixSort(arr);
        for (int num : arr) System.out.print(num + " "); System.out.println();
    }
}

• Python

def counting_sort_by_digit(arr, exp):
    n = len(arr)
    output = [0] * n
    count = [0] * 10
    for i in range(n): count[(arr[i] // exp) % 10] += 1
    for i in range(1, 10): count[i] += count[i - 1]
    for i in range(n - 1, -1, -1):
        output[count[(arr[i] // exp) % 10] - 1] = arr[i]
        count[(arr[i] // exp) % 10] -= 1
    for i in range(n): arr[i] = output[i]
def radix_sort(arr):
    if len(arr) <= 1: return
    max_val = max(arr)
    exp = 1
    while max_val // exp > 0:
        counting_sort_by_digit(arr, exp)
        exp *= 10
arr = [ 170, 45, 75, 90, 802, 24, 2, 66 ]
radix_sort(arr)
print(' '.join(map(str, arr)))

结语
感谢您的阅读！期待您的一键三连！欢迎指正！