23. 合并 K 个升序链表

题目描述

　　给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。

题解

/**
 * 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 {
    // 思路1:利用java的PriorityQueue（推荐）

    // 思路2:把集合中所有的数字加入到一个集合中，然后把集合按升序排序，然后按照顺序创建ListNode

    // 思路3:采用合并两个有序链表的方法，两两合并，即让第一个依次和后面的链表合并


    // 思路1
    public ListNode mergeKLists(ListNode[] lists) {
        // 将list中的listNode按照val从小到大的顺序加入到优先队列
        PriorityQueue<ListNode> priorityQueue = new PriorityQueue<>((o1, o2) -> o1.val - o2.val); 
        for (ListNode each : lists) {
            if (each == null) {
                continue;
            }
            priorityQueue.add(each);
        }

        ListNode head = new ListNode(); // 链表的头
        ListNode cur = head; // 移动指针
        while (!priorityQueue.isEmpty()) {
            ListNode tem = priorityQueue.poll(); // 从优先队列中弹出val最小的listNode
            cur.next = tem;
            cur = cur.next;
            if (tem.next != null) { // 如果该链表的next不为空，继续把next加入到优先队列
                priorityQueue.add(tem.next);
            }
        }
        return head.next;
    }


    // 思路2
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        List<Integer> list = new ArrayList<>();
        for (ListNode each : lists) { // 将所有的数字加入到list集合中
            while (each != null) {
                list.add(each.val);
                each = each.next;
            }
        }
        Collections.sort(list); // 将集合中的数字从小到大排序
        int listSize = list.size();
        ListNode head = new ListNode();
        ListNode cur = head;     
        for (int i = 0; i < listSize ; i++) { 
            ListNode node = new ListNode(list.get(i)); // 按照顺序从集合中拿数字，并创建新链表
            cur.next = node;
            cur = cur.next; 
        }
        return head.next;
    }


    // 思路3
    public ListNode mergeKLists(ListNode[] lists) {
        // 当lists中的元素个数小于2个
        if (lists.length == 0 || lists.length == 1) {
            return lists.length == 0 ? null : lists[0];
        }
        // 第一个ListNode逐渐与后面的每一个合并，n个元素需要合并n - 1次
        ListNode first = lists[0];
        for (int i = 1; i < lists.length; i++) {
            first = mergeTwoList(first, lists[i]); // 每合并一次first就会被更新
        }
        return first;
    }

    // 合并两个有序链表
    ListNode mergeTwoList(ListNode listNode1, ListNode listNode2) {
        ListNode head = new ListNode(); // 自定义一个头节点
        ListNode cur = head; 
        while (listNode1 != null && listNode2 != null) { // 当listNode1和listNode2同时不为空进入循环
            if (listNode1.val >= listNode2.val) { // cur的next指向val小的节点
                cur.next = listNode2;
                listNode2 = listNode2.next;
            } else {
                cur.next = listNode1;
                listNode1 = listNode1.next;
            }
            cur = cur.next; // cur指针后移
        }

        // 两个链表连接过程中，总会有一个链表先被连接完，剩下的链表节点直接连接在后面即可
        if (listNode1 == null) {
            cur.next = listNode2;
        }
        if (listNode2 == null) {
            cur.next = listNode1;
        }
        return head.next;
    }

}