持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第2天，点击查看活动详情

(LeetCode刷题打卡)

一、（简单题）506.相对名次

LeetCode原题链接：506.相对名次

题目描述：

给你一个长度为 n 的整数数组 score ，其中 score[i] 是第 i 位运动员在比赛中的得分。所有得分都 互不相同 。

运动员将根据得分 决定名次 ，其中名次第 1 的运动员得分最高，名次第 2 的运动员得分第 2 高，依此类推。运动员的名次决定了他们的获奖情况：

• 名次第 1 的运动员获金牌 "Gold Medal" 。
• 名次第 2 的运动员获银牌 "Silver Medal" 。
• 名次第 3 的运动员获铜牌 "Bronze Medal" 。
• 从名次第 4 到第 n 的运动员，只能获得他们的名次编号（即，名次第 x 的运动员获得编号 "x"）。

使用长度为 n 的数组 answer 返回获奖，其中 answer[i] 是第 i 位运动员的获奖情况。 示例 1： 输入：score = [5,4,3,2,1]
输出：["Gold Medal","Silver Medal","BronzeMedal","4","5"] 解释：名次为 [1st, 2nd, 3rd, 4th, 5th] 。
示例 2： 输入：score = [10,3,8,9,4]
输出：["GoldMedal","5","BronzeMedal","Silver Medal","4"]
解释：名次为 [1st, 5th, 3rd, 2nd, 4th] 。

解题思路： 题目要求根据得分决定名次，而给定的数组中，运动员们的得分是没有顺序的，这时候我们就需要将分数排序，按照排名给运动员们的得分附上获奖情况。

我们可以选择堆排序，将所有运动员的得分放入最大堆中，那么从堆中取出来的得分将是由大到小的，给answer[]前三名分别赋值 "Gold Medal"，"Silver Medal"和"Bronze Medal"，余下的直接赋值（名次+“ ”）。

但是我们这是又会遇到问题，分数虽然排序好了，可是顺序也被打乱了，不知道哪个运动员对应哪一个得分。

为了让堆中排序好的得分与运动员对应，可以使用有序可重复的集合List来存放得分数组score[]， 数组下标就是运动员的位置下标，让堆中取出的得分与集合中元素一比较，就得到了对应运动员的下标，并为运动员们附上名次。

解题代码：

class Solution {
    public String[] findRelativeRanks(int[] score) {
    //创建优先队列对象（默认最小堆），重写比较器，改为最大堆。
        PriorityQueue<Integer> que = new PriorityQueue<>(new Comparator<Integer>(){
            public int compare(Integer a,Integer b){
                return b.compareTo(a);
            }
        });
        //创建集合list
        List list = new ArrayList();
        //增强for循环
        for(int scores : score){
        //得分放入最大堆堆中进行排序
            que.offer(scores);
        //得分放入集合中
            list.add(scores);
        }
        int num;//表示堆中取出的得分
        int index;//表示得分对应的运动员下标
        String[] answer = new String[score.length];
        for(int i = 0;i <= score.length-1;++i){
            num = que.poll();             //从堆中取出得分
            index = list.indexOf(num);    //通过得分在集合中找到对应下标
            if(i == 0){//第一名
                answer[index] = "Gold Medal";
            }else if(i == 1){//第二名
                answer[index] = "Silver Medal";
            }else if(i == 2){//第三名
                answer[index] = "Bronze Medal";
            }else{//名次转化为字符串类型，放入数组中
                answer[index] = i+1+"";
            }
            }
            return answer;//返回获奖情况
        }
    }

提交结果：

二、（中等）264.丑数

LeetCode原题链接：264.丑数

题目描述：

给你一个整数 n ，请你找出并返回第 n 个 丑数 。

丑数 就是只包含质因数 2、3 和/或 5 的正整数。 / 示例 1： 输入：n = 10 输出：12 解释：[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。 / 示例 2： 输入：n = 1 输出：1 解释：1 通常被视为丑数。

解题思路： 题目要求是求出第n个丑数，其实我们只需要抓住本质即可找到思路，丑数的本质在于那三个质因数2，3，5；

同时需要注意的是 1 也是丑数，而后面的所有偶数，都可以从每个偶数与质因数2，3，5的乘积中得到，这么一来，思路是不是就清晰了？

我们将 1 分别与三个质因数相乘，获得后面的三个丑数，又根据获得的丑数与三个质因数的乘积，不断重复操作，前n个丑数就到手了...

但是不能忽略了细节，单纯按照上述的操作解题是会出现问题的：成绩当中可能会出现重复的数，这样子取得的第n个丑数就不准确了。

为了解决重复的问题，我们需要借助内容不可重复的集合Set，只需要在记录丑数之前，看得到的丑数能否加入到Set集合中，就能排除重复冗余的元素了。

我们需要得到第n个数，这 n 个数是存在一个由小到大顺序的，所以我们还需要给记录下来的数排序，这时候，我们完全可以使用最小堆这个数据结构，每个元素被记录下来的同时就排好序了。

每次取出的堆顶元素都是最小的元素，取出n个就是前n个丑数，取出第n个就是第n个丑数。

解题代码：

class Solution {
    public int nthUglyNumber(int n) {
        int[] factors = {2,3,5};
        Set<Long> set = new HashSet<Long>();//创建集合
        //创建优先序列（默认最小堆）
        PriorityQueue<Long> que = new PriorityQueue<Long>();
        int ugly  = 0;//表示丑数
        set.add(1l);//第一个丑数1放进集合
        que.add(1l);//第一个丑数1放进最小堆
        //循环取出前n个丑数
        for(int i = 0;i < n; ++i){
        //从堆中取出当前丑数，赋值给ugly
            long curr = que.poll();
            ugly = (int)curr;
            //用丑数分别与2，3，5相乘，获得后续丑数
            for(int factor : factors){
                long next = curr*factor;
                if(set.add(next)){//放进集合去重
                    que.offer(next);//放进最小堆
                }
            }
        }
        return ugly;//返回第n个丑数
    }
}

提交结果：

三、（困难）23.合并N个升序链表

做不出来，看了题解之后才完成的.....

LeetCode原题链接：23.合并N个升序链表

题目描述：

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。 /

示例 1：

输入：lists = [ [1,4,5], [1,3,4], [2,6] ] 输出：[1,1,2,3,4,4,5,6] 解释：链表数组如下： [
1->4->5,
1->3->4, 2->6 ] 将它们合并到一个有序链表中得到。 1->1->2->3->4->4->5->6 / 示例 2：

输入：lists = [] 输出：[] / 示例 3：

输入：lists = [[]] 输出：[]

思路：分别将链表数组中，每个链表的首元素放入最小堆，选出最小的元素放入新链表，选出元素的下一个节点进堆，继续排序，重复上述操作，直到堆空为止。 这样就实现了合并后的链表依旧保持升序。 解题代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists.length == 0)
        return null;

        ListNode list = new ListNode(0);//创建链表
        ListNode curr = list;//将链表第一个值传入
        PriorityQueue<ListNode> que = new PriorityQueue<>(new Comparator<ListNode>(){
            public int compare(ListNode a,ListNode b){
                return a.val-b.val;
            }
        });//创建优先队列（最小堆）

        //将链表数组中，每个链表元素的首元素放入堆
        for(ListNode list1 : lists){
            if(list1 == null) continue;
            que.offer(list1);
        }

        while(!(que.isEmpty())){//堆不为空时，循环操作
            ListNode nextNode = que.poll();//最小的元素出堆
            curr.next = nextNode;//链表的下一位指向最小元素
            curr = curr.next;//链表指向下一位
            if(nextNode.next != null){
                que.offer(nextNode.next);//出堆元素的下一位入堆排序
            }
        }
        return list.next;//跳过头节点，返回链表的下一个元素
    }
}

提交结果：