【Day 01】力扣（LeetCode）每日一刷[506.相对名次][264.丑数][23.合并N个升序链表]

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;//返回获奖情况
        }
    }

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个丑数
    }
}

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

/**
 * 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;//跳过头节点，返回链表的下一个元素
    }
}