【数据结构与算法】基数排序计数排序桶排序_基数排序、计数排序、桶排序(1)

最新推荐文章于 2024-09-13 16:27:15 发布

2401_84164672

最新推荐文章于 2024-09-13 16:27:15 发布

阅读量248

点赞数 7

分类专栏：程序员文章标签：算法 java 数据结构

本文链接：https://blog.csdn.net/2401_84164672/article/details/138423126

版权

程序员专栏收录该内容

185 篇文章 1 订阅

订阅专栏

本文介绍了计数排序和基数排序这两种非比较型整数排序算法，强调了它们的时间复杂度和适用场景，以及基数排序在处理大数据范围数组的优势。

摘要由CSDN通过智能技术生成

    for (long temp = num; temp != 0; temp /= 10) {
        lenght++;
    }
    return lenght;
}

private int[] radixSort(int[] arr, int maxDigit) {
    int mod = 10;
    int dev = 1;

    for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        // 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
        int[][] counter = new int[mod * 2][0];

        for (int j = 0; j < arr.length; j++) {
            int bucket = ((arr[j] % mod) / dev) + mod;
            counter[bucket] = arrayAppend(counter[bucket], arr[j]);
        }

        int pos = 0;
        for (int[] bucket : counter) {
            for (int value : bucket) {
                arr[pos++] = value;
            }
        }
    }

    return arr;
}


#### 1.计数排序的特征


当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。


由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。


#### 2.复杂度分析


计数排序：范围小 且集中的数据


时间复杂度：O(n+范围) -> 范围越小,时间复杂度越小


空间复杂度：O(范围)


## 二、基数排序


基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。


![](https://img-blog.csdnimg.cn/b48edf29e8f545afaaf03609ddcf4edc.gif)


**代码实现：**

public class RadixSort implements IArraySort {

@Override
public int[] sort(int[] sourceArray) throws Exception {
    // 对 arr 进行拷贝，不改变参数内容
    int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

    int maxDigit = getMaxDigit(arr);
    return radixSort(arr, maxDigit);
}

/**
 * 获取最高位数
 */
private int getMaxDigit(int[] arr) {
    int maxValue = getMaxValue(arr);
    return getNumLenght(maxValue);
}

private int getMaxValue(int[] arr) {
    int maxValue = arr[0];
    for (int value : arr) {
        if (maxValue < value) {
            maxValue = value;
        }
    }
    return maxValue;
}

protected int getNumLenght(long num) {
    if (num == 0) {
        return 1;
    }
    int lenght = 0;
    for (long temp = num; temp != 0; temp /= 10) {
        lenght++;
    }
    return lenght;
}

private int[] radixSort(int[] arr, int maxDigit) {
    int mod = 10;
    int dev = 1;

    for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        // 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
        int[][] counter = new int[mod * 2][0];

        for (int j = 0; j < arr.length; j++) {
            int bucket = ((arr[j] % mod) / dev) + mod;
            counter[bucket] = arrayAppend(counter[bucket], arr[j]);
        }

        int pos = 0;
        for (int[] bucket : counter) {
            for (int value : bucket) {
                arr[pos++] = value;
            }
        }
    }

    return arr;
}

/**
 * 自动扩容，并保存数据
 *
 * @param arr
 * @param value
 */
private int[] arrayAppend(int[] arr, int value) {
    arr = Arrays.copyOf(arr, arr.length + 1);
    arr[arr.length - 1] = value;
    return arr;
}

}


##  三、桶排序


**桶排序 (Bucket sort)**或所谓的**箱排序**，是一个排序算法，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的[排序算法](https://bbs.csdn.net/topics/618545628)或是以递归方式继续使用桶排序进行排序）。桶排序是[鸽巢排序](https://bbs.csdn.net/topics/618545628)的一种[归纳](https://bbs.csdn.net/topics/618545628)结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（[Θ](https://bbs.csdn.net/topics/618545628)（*n*））。但桶排序并不是 比较排序，他不受到 O(n log n) [下限](https://bbs.csdn.net/topics/618545628)的影响。


![](https://img-blog.csdnimg.cn/5365c7f046ca4b18b7b8257c3bc4444d.gif)


**代码实现：**

public class BucketSort implements IArraySort {

private static final InsertSort insertSort = new InsertSort();

@Override
public int[] sort(int[] sourceArray) throws Exception {
    // 对 arr 进行拷贝，不改变参数内容
    int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

    return bucketSort(arr, 5);
}

private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
    if (arr.length == 0) {
        return arr;
    }

    int minValue = arr[0];
    int maxValue = arr[0];
    for (int value : arr) {
        if (value < minValue) {
            minValue = value;
        } else if (value > maxValue) {
            maxValue = value;
        }
    }

    int bucketCount = (int) Math.floor((maxValue - minValue) / bucketSize) + 1;
    int[][] buckets = new int[bucketCount][0];

    // 利用映射函数将数据分配到各个桶中
    for (int i = 0; i < arr.length; i++) {