• Java手写基数排序和算法案例拓展

    Java手写基数排序和算法案例拓展

    1. 算法思维导图
    基数排序
    实现思路原理
    手写必要性
    市场调查
    详细介绍和步骤
    手写实现总结
    思维拓展

    2. 实现思路原理

    实现思路原理：

    1. 找到待排序序列中的最大值。
    2. 确定排序的轮数，即最大值的位数。
    3. 按照位数进行计数排序：
      • 创建10个桶，分别代表0-9的数字。
      • 将手机号码或字符串按照当前位数上的数字放入对应的桶中。
      • 将桶中的手机号码或字符串按照顺序取出，覆盖原数组。
    4. 重复第3步，直到所有位数都被处理完毕。
    5. 完成排序。

    这就是基数排序的实现思路原理。它通过按照数字或字符的位数进行计数排序，从而实现对整个序列的排序。每一轮排序都会根据当前位数上的数字或字符，将序列分配到对应的桶中，然后按照桶的顺序取出，最终完成排序。通过多轮排序，可以确保所有位数上的数字或字符都被正确排序，从而得到最终的有序序列。
    基数排序是一种非比较排序算法，它将待排序的元素按照低位到高位的顺序依次进行排序。基数排序的核心思想是通过对待排序元素的每一位进行计数排序，最终得到有序序列。

    3. 手写必要性

    手写基数排序的过程可以帮助我们更深入地理解算法的原理和实现细节。通过手写基数排序，我们可以加深对排序算法的理解，并且可以根据实际需求进行优化和改进。

    4. 市场调查

    在实际应用中，基数排序算法在大数据量和位数较多的情况下具有较高的效率。尤其在数字排序、字符串排序等领域有着广泛的应用。

    5. 详细介绍和步骤

    步骤1：找到待排序序列中的最大值

    遍历待排序序列，找到最大值max。

    步骤2：确定排序的轮数

    根据最大值max的位数确定需要进行的排序轮数。例如，如果max为3位数，则需要进行3轮排序。

    步骤3：按照个位数进行计数排序

    创建10个桶，分别代表0到9这10个数字。根据个位数的值将待排序序列中的元素分配到对应的桶中。然后按照桶的顺序将元素依次取出，得到一个新的序列。

    步骤4：按照十位数进行计数排序

    将第3步得到的新序列作为待排序序列，再次进行计数排序，只不过这次是按照十位数的值进行排序。

    步骤5：重复步骤4，直到最高位数排序完成

    重复步骤4，按照百位、千位等依次进行计数排序，直到最高位数排序完成。

    步骤6：得到有序序列

    经过多轮计数排序后，最终得到的序列就是有序序列。

    6. 手写实现总结

    通过手写基数排序，我更加深入地理解了算法的原理和实现细节。基数排序是一种非常高效的排序算法，尤其适用于大数据量和位数较多的情况。同时，手写实现也让我能够根据实际需求进行优化和改进。

    7. 思维拓展

    基数排序可以应用于数字排序、字符串排序等领域。同时，基数排序还可以与其他排序算法结合使用，例如与快速排序结合，先按照高位进行基数排序，再使用快速排序对每个桶进行排序，从而提高排序的效率。

    8. 完整代码

    // 基数排序
public class RadixSort {
    public static void radixSort(int[] arr) {
        // 步骤1：找到待排序序列中的最大值
        int max = findMax(arr);
        
        // 步骤2：确定排序的轮数
        int maxDigit = getMaxDigit(max);
        
        // 步骤3到5：按照位数进行计数排序
        for (int i = 1; i <= maxDigit; i++) {
            countingSort(arr, i);
        }
    }
    
    // 找到待排序序列中的最大值
    private static int findMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
    
    // 获取最大值的位数
    private static int getMaxDigit(int max) {
        int digit = 1;
        while (max >= 10) {
            max /= 10;
            digit++;
        }
        return digit;
    }
    
    // 按照指定位数进行计数排序
    private static void countingSort(int[] arr, int digit) {
        int[] count = new int[10];
        int[] temp = new int[arr.length];
        
        // 统计每个桶中的元素个数
        for (int i = 0; i < arr.length; i++) {
            int num = getDigit(arr[i], digit);
            count[num]++;
        }
        
        // 计算每个桶的边界索引
        for (int i = 1; i < count.length; i++) {
            count[i] += count[i - 1];
        }
        
        // 将元素放入对应的桶中
        for (int i = arr.length - 1; i >= 0; i--) {
            int num = getDigit(arr[i], digit);
            temp[count[num] - 1] = arr[i];
            count[num]--;
        }
        
        // 将临时数组复制回原数组
        System.arraycopy(temp, 0, arr, 0, arr.length);
    }
    
    // 获取指定位数上的数字
    private static int getDigit(int num, int digit) {
        return (num / (int) Math.pow(10, digit - 1)) % 10;
    }
    
    // 测试
    public static void main(String[] args) {
        int[] arr = {53, 3, 542, 748, 14, 214, 154, 63, 616};
        radixSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77

    9. 应用前景调研

    基数排序在大数据量和位数较多的情况下具有较高的效率，因此在数字排序、字符串排序等领域有着广泛的应用前景。尤其是在处理海量数据、大规模数据分析等场景下，基数排序可以发挥出更大的优势。

    10. 拓展应用案例

    案例1：手机号码排序

    假设有一批手机号码需要排序，可以使用基数排序按照手机号码的位数进行排序，从而达到快速排序的目的。

    // 基于基数排序的手机号码排序
public class PhoneSort {
    public static void phoneSort(String[] arr) {
        // 步骤1：找到待排序序列中的最大值
        int max = findMax(arr);
        
        // 步骤2：确定排序的轮数
        int maxDigit = getMaxDigit(max);
        
        // 步骤3到5：按照位数进行计数排序
        for (int i = 1; i <= maxDigit; i++) {
            countingSort(arr, i);
        }
    }
    
    // 找到待排序序列中的最大值
    private static int findMax(String[] arr) {
        int max = arr[0].length();
        for (int i = 1; i < arr.length; i++) {
            if (arr[i].length() > max) {
                max = arr[i].length();
            }
        }
        return max;
    }
    
    // 获取最大值的位数
    private static int getMaxDigit(int max) {
        return max;
    }
    
    // 按照指定位数进行计数排序
    private static void countingSort(String[] arr, int digit) {
        List<String>[] buckets = new ArrayList[10];
        for (int i = 0; i < 10; i++) {
            buckets[i] = new ArrayList<>();
        }
        
        // 将手机号码放入对应的桶中
        for (String phone : arr) {
            int num = getDigit(phone, digit);
            buckets[num].add(phone);
        }
        
        // 将桶中的手机号码按照顺序取出
        int index = 0;
        for (List<String> bucket : buckets) {
            for (String phone : bucket) {
                arr[index] = phone;
                index++;
            }
        }
    }
    
    // 获取指定位数上的数字
    private static int getDigit(String phone, int digit) {
        if (digit > phone.length()) {
            return 0;
        }
        return Character.getNumericValue(phone.charAt(phone.length() - digit));
    }
    
    // 测试
    public static void main(String[] args) {
        String[] arr = {"13812345678", "13987654321", "13765432109", "13678901234", "13543219876"};
        phoneSort(arr);
        for (String phone : arr) {
            System.out.println(phone);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71

    案例2：字符串排序

    假设有一批字符串需要排序，可以使用基数排序按照字符串的字符进行排序，从而达到快速排序的目的。

    // 基于基数排序的字符串排序
public class StringSort {
    public static void stringSort(String[] arr) {
        // 步骤1：找到待排序序列中的最大值
        int max = findMax(arr);
        
        // 步骤2：确定排序的轮数
        int maxDigit = getMaxDigit(max);
        
        // 步骤3到5：按照位数进行计数排序
        for (int i = 1; i <= maxDigit; i++) {
            countingSort(arr, i);
        }
    }
    
    // 找到待排序序列中的最大值
    private static int findMax(String[] arr) {
        int max = arr[0].length();
        for (int i = 1; i < arr.length; i++) {
            if (arr[i].length() > max) {
                max = arr[i].length();
            }
        }
        return max;
    }
    
    // 获取最大值的位数
    private static int getMaxDigit(int max) {
        return max;
    }
    
    // 按照指定位数进行计数排序
    private static void countingSort(String[] arr, int digit) {
        List<String>[] buckets = new ArrayList[26];
        for (int i = 0; i < 26; i++) {
            buckets[i] = new ArrayList<>();
        }
        
        // 将字符串放入对应的桶中
        for (String str : arr) {
            int num = getDigit(str, digit);
            buckets[num].add(str);
        }
        
        // 将桶中的字符串按照顺序取出
        int index = 0;
        for (List<String> bucket : buckets) {
            for (String str : bucket) {
                arr[index] = str;
                index++;
            }
        }
    }
    
    // 获取指定位数上的字符
    private static int getDigit(String str, int digit) {
        if (digit > str.length()) {
            return 0;
        }
        return str.charAt(str.length() - digit) - 'a';
    }
    
    // 测试
    public static void main(String[] args) {
        String[] arr = {"hello", "world", "java", "programming", "algorithm"};
        stringSort(arr);
        for (String str : arr) {
            System.out.println(str);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71

    以上是基于基数排序的手机号码排序和字符串排序的实现，可以根据实际需求进行优化和改进。

  • 相关阅读:
    SpringSecurity基础概念和案例代码
    基于SpringBoot+Vue的闲一品交易平台设计与实现
    LeetCode0076.最小覆盖子串 Go语言AC笔记
    【PyTorch深度学习项目实战100例】—— 基于MFCC对GTZAN音乐流派分类 | 第66例
    我的创作纪念日
    Java多线程学习入门(六)：锁升级、锁消除、锁粗化
    Windows 程序安装与更新方案： Clowd.Squirrel
    话费充值接口文档
    环境多介质逸度模型与典型案例【代码】应用
    find用法
  • 原文地址：https://blog.csdn.net/qq_22593423/article/details/132927904