LeetCode-179. 最大数-Java-medium

happy life 2022

已于 2022-09-14 17:45:09 修改

阅读量158

点赞数

分类专栏： # 其他文章标签： java leetcode 算法

于 2022-09-14 17:43:30 首次发布

本文链接：https://blog.csdn.net/qq_41829337/article/details/126856952

版权

其他专栏收录该内容

30 篇文章 0 订阅

订阅专栏

题目链接

法一（优先队列）

    /**
     * 法一（优先队列）
     * 1.  PriorityQueue
     *    （1）PriorityQueue类是基于优先级堆的无界队列
     *    （2）优先队列中的元素可以默认自然排序或者通过提供的Comparator（比较器）在队列实例化时排序
     * 2. 思路
     *    （1）自定义一种排序方式，比较 s1 + s2 和 s2 + s1
     *    （2）例如10 2，连接起来分别是 210 和 102 ，将大的放在高位
     *
     * @param nums
     * @return
     */
    public String largestNumber(int[] nums) {
        if (nums == null || nums.length == 0) {
            return "";
        }
        List<String> list = new LinkedList<>();
        for (int num : nums) {
            list.add(String.valueOf(num));
        }
        PriorityQueue<String> priorityQueue = new PriorityQueue<>((o1, o2) -> {
            return (o2 + o1).compareTo(o1 + o2); // 修改排序规则以实现大顶堆
        });
        priorityQueue.addAll(list); // 构建大顶堆
        StringBuilder sb = new StringBuilder();
        while (!priorityQueue.isEmpty()) {
            sb.append(priorityQueue.remove());  // 移除优先队列堆顶元素并添加到sb中
        }
        if (sb.toString().charAt(0) == '0') {   // 特殊情况，若干个零
            return "0";
        }
        return sb.toString();
    }

法二（排序）

    /**
     * 法二（排序）
     * compareTo方法返回值为1（升序），0，-1（降序）
     *
     * @param nums
     * @return
     */
    public String largestNumber_2(int[] nums) {
        if (nums == null || nums.length == 0) {
            return "";
        }
        String[] strs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            strs[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(strs, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) { // 重载比较器
                return (o2 + o1).compareTo(o1 + o2);   // 返回正值交换，返回负值不交换
            }
        });
        if (strs[0].charAt(0) == '0') {   // 特殊情况，若干个零
            return "0";
        }
        return String.join("", strs); // 拼接返回
    }

法三（排序 + 流式编程）

    /**
     * 法三（排序 + 流式编程），较慢
     * 流式编程操作步骤
     * （1）创建Stream，从集合、数组中获取一个流
     * （2）中间操作链，对数据进行处理
     * （3）终端操作，用来执行中间操作链，返回结果
     *
     * @param nums
     * @return
     */
    public String largestNumber_3(int[] nums) {
        return Arrays.stream(nums)      // 转成IntStream，即int类型的流
                .boxed()                // 转成Stream<Integer>，即Integer类型的流
                .map(String::valueOf)   // 转成Stream<String>，即String类型的流
                .sorted((o1, o2) -> (o2 + o1).compareTo(o1 + o2)) // 对流中的数据按照自定义的规则进行排序
                .reduce(String::concat) // 将流中的数据连接在一起
                .filter(s -> !s.startsWith("0")) // 过滤出不以"0"开头的字符串
                .orElse("0");     // 如果没有这样的字符串则返回"0"
    }

本地测试

        /**
         * 179. 最大数
         */
        lay.showTitle(179);
        Solution179 sol179 = new Solution179();
        int[] nums179 = new int[]{3, 30, 34, 5, 9};
        System.out.println(Arrays.toString(nums179));
        System.out.println(sol179.largestNumber(nums179));
        System.out.println(sol179.largestNumber_2(nums179));
        System.out.println(sol179.largestNumber_3(nums179));