线性排序（Linear sort）

线性排序（Linear sort）

在 Python 中，你可以使用列表（list）来创建一个指定大小的数组。以下是一个示例：

# 创建一个长度为 10 的数组，所有元素都初始化为 0
arr = [0] * 10

这段代码会创建一个包含 10 个元素的列表，所有元素都初始化为 0。

如果你想要创建一个二维数组，你可以使用嵌套的列表。以下是一个示例：

# 创建一个 5x5 的二维数组，所有元素都初始化为 0
arr = [[0] * 5 for _ in range(5)]

arr = [[] for _ in range(5)]

这段代码会创建一个包含 5 行 5 列的二维数组，所有元素都初始化为 0。

在 Python 中，你可以使用整除（//）和模（%）运算符来取出一个整数的十位。以下是一个示例：

num = 1234
tens_digit = num // 10 % 10

这段代码首先使用整除运算符（//）移除 num 的个位，然后使用模运算符（%）取出 num 的十位。

在 Java 中，你也可以使用整除（/）和模（%）运算符来取出一个整数的十位。以下是一个示例：

int num = 1234;
int tensDigit = num / 10 % 10;

这段代码首先使用整除运算符（/）移除 num 的个位，然后使用模运算符（%）取出 num 的十位。

在 Java 中，你可以使用 Math.pow() 方法来表示 10 的几次方。以下是一个示例：

double result = Math.pow(10, 2);  // 计算 10 的 2 次方

这段代码会计算 10 的 2 次方，并将结果存储在 result 变量中。

请注意，Math.pow() 方法的结果是一个 double 类型的值。如果你需要一个整数结果，你可以使用类型转换将其转换为 int：

int result = (int) Math.pow(10, 2);  // 计算 10 的 2 次方并转换为 int

桶排序（Bucket sort）

和上面的区别就是分桶的方法不一样

int a[]= {1,8,7,44,42,46,38,34,33,17,15,16,27,28,24};

把以上的数组按大小每10分到一个桶，然后在每个桶里再排序，最后拼起来。

以下是按大小范围分桶

java实现

public static void bucketSort(int[] a) {
    List[] buckets = new ArrayList[5];

    // 初始化
    for (int i = 0; i < buckets.length; i++) {
        buckets[i] = new ArrayList<Integer>();
    }
    // 将待排序序列放入对应桶中
    for (int i = 0; i < a.length; i++) {
        int index = a[i] / 10;// 对应的桶号
        buckets[index].add(a[i]);
    }
    int index = 0;
    // 使用自带排序对每个桶内进行排序
    for (int i = 0; i < buckets.length; i++) {
        buckets[i].sort(null);
        for (int j = 0; j < buckets[i].size(); j++) {
            a[index++] = (Integer) buckets[i].get(j);
        }
    }
}

python实现

def sortDemo2(a: list):
    # 初始化二维数组
    buckets = [[] for _ in range(5)]

    # 将待排序序列放入对应桶中
    for num in a:
        # 对应的桶号
        index = num // 10
        buckets[index].append(num)
    index = 0
    for bucket in buckets:
        # 使用自带排序算法把桶中的进行排序
        bucket.sort()
        # 依次取出桶中的每个数
        for num in bucket:
            a[index] = num
            index += 1

计数排序（Counting sort）

计数其实就是特殊的桶，在划分桶的时候，把每个数放到一个桶，这样每个桶里面的数都是一样的。

java实现

public static void countingSort(int[] num) {
    // 求出最大值
    int max = num[0];
    for (int i = 0; i < num.length; i++) {
        if (num[i] > max) {
            max = num[i];
        }
    }
    // 创建一个长度为原始数组中最大值的桶数组,该桶数组的下标代表元素，该数组下标所对应的值代表这个值出现的次数
    int[] bucketArray = new int[max + 1];
    // 再次遍历原始数组，得到原数组中存在的各个元素，以及出现的次数
    for (int i = 0; i < num.length; i++) {
        bucketArray[num[i]]++;
    }
    // 遍历桶数组,外层循环从桶的第一位开始（即下表为零）；内层循环遍历桶数组中下标为i的值出现的次数
    int index = 0;
    for (int i = 0; i < bucketArray.length; i++) {
        for (int j = 0; j < bucketArray[i]; j++) {
            num[index++] = i;
        }
    }
}

python实现

def sortDemo3(a: list):
    # 求出最大值
    max_num = max(a)
    # 创建一个长度为原始数组中最大值的桶数组,该桶数组的下标代表元素，该数组下标所对应的值代表这个值出现的次数
    buckets = [0] * (max_num + 1)
	# 再次遍历原始数组，得到原数组中存在的各个元素，以及出现的次数
    for num in a:
        buckets[num] += 1
    # 遍历桶数组,外层循环从桶的第一位开始（即下表为零）；内层循环遍历桶数组中下标为i的值出现的次数
    index = 0
    for i, sum in enumerate(buckets):
        for num in range(sum):
            a[index] = i
            index += 1

基数排序（Radix sort）

这是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（例如时间和日期），所以基数排序也不仅可以用于整数，还可以用于排序字符串。

这个方法的主要步骤如下：

1. 初始化一个大小为 10 的桶数组，因为每个位的数字只能从 0 到 9。
2. 对于待排序数组中的每个元素，根据其某一位的数字（先低位后高位）放入对应的桶中。
3. 对每个桶中的元素进行排序（这里使用了 Java 的内置排序方法）。
4. 按照桶的顺序（从 0 到 9）依次取出桶中的元素，放回到原数组中。
5. 重复步骤 2-4，直到所有位都被处理过。

这个方法已经很高效了，因为基数排序的时间复杂度为 O(nk)，其中 n 是待排序数组的长度，k 是数字位数。但是如果你想要进一步优化这个方法，你可以考虑以下几点：

• 在这个方法中，无论待排序数组的实际情况如何，都对所有位进行了处理。如果你知道待排序数组的最大值，你可以只处理到最大值的最高位。
• 这个方法在处理每一位时都对桶进行了初始化和排序操作。你可以考虑使用稳定的计数排序算法替代内置的排序方法，并且只在处理最低位时进行初始化操作。
• 如果待排序数组的长度 n 和范围 k 满足 n >> k（即 n 远大于 k），那么基数排序可能不如其他算法（例如快速排序、归并排序等）效率高。在选择排序算法时，应根据待排序数组的实际情况来决定。

请注意，以上只是一些可能的优化建议，并不能保证在所有情况下都能提高效率。在进行优化之前，你应该先分析待排序数组的实际情况和需求。

注意：

后续的排序算法得是稳定的，不然之前的排序就被打乱了

python实现

def sortDemo(a: list):
    for i in range(3):
        # 初始化桶数组（二维数组）
        buckets = [[] for _ in range(10)]

        # 将待排序序列放入对应桶中
        for num in a:
            # 对应的桶号
            index = num // 10 ** i % 10
            buckets[index].append(num)
        index = 0
        # 把桶中的每一项再取出来
        for bucket in buckets:
            for num in bucket:
                a[index] = num
                index += 1

java实现

public static void sortDemo(int[] b) {
    List[] buckets = new ArrayList[10];

    for (int l = 0; l < 3; l++) {
        int k = (int) Math.pow(10, l);
        // 初始化构造二维数组
        for (int i = 0; i < buckets.length; i++) {
            buckets[i] = new ArrayList<Integer>();
        }

        // 将待排序序列放入对应桶中
        for (int i = 0; i < b.length; i++) {
            // 对应的桶号
            int index = b[i] / k % 10;
            buckets[index].add(b[i]);
        }
        int index = 0;
        // 把桶中的每一项再取出来
        for (int i = 0; i < buckets.length; i++) {
            for (int j = 0; j < buckets[i].size(); j++) {
                b[index++] = (Integer) buckets[i].get(j);
            }
        }
    }
}