每日一题—23. 合并K个排序链表

今天是2020年4月26日，星期日。今天正好是链表的问题，然后去学习了一下LeetCode上的weiwei大佬的「单链表」总结。同时欢迎大家加入每日一题打卡组织：每日一题打卡。

题目描述

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

题目分析与参考代码

自己的想法

在拿到题目后，发现是K个排序链表的合并，想到了weiwei大佬之前说过的链表的「穿针引线」，每次从链表的头结点来选择一个值最小的节点来放到最终的结果中，然后继续选择。当K个链表中都没有新元素后，即结束循环。最终调试后，通过LeetCode测试用例，但是用时较多。

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        // 添加一个虚拟节点
        ListNode head = new ListNode(-1);
        ListNode current = head;
        int length = lists.length;
        ListNode[] pointer = new ListNode[length];

        // 初始化每个指针
        for (int i = 0; i < length; i++) {
            pointer[i] = lists[i];
        }

        while (true) {
            int max = Integer.MAX_VALUE;
            // 用于替换向下一个节点
            int index = -1;
            for (int i = 0; i < length; i++) {
                if (pointer[i] != null && pointer[i].val < max) {
                    max = pointer[i].val;
                    index = i;
                }
            }
            // 如果没有节点，即退出循环
            if (index == -1) {
                break;
            }

            ListNode node = new ListNode(pointer[index].val);
            current.next = node;
            current = node;
            pointer[index] = pointer[index].next;
        }

        return head.next;
    }
}

复杂度分析：

• 时间复杂度：O(NK)，N为最长链表的节点数，K为链表条数。每次需要遍历K条链表的头结点，时间复杂度为O(K)。
• 空间复杂度：O(K)，使用了固定空间的辅助数组。

参考甜姨题解「4 种方法详解，🤷‍♀️必须秒懂！」

使用小根堆对上述算法进行优化

使用Java中的优先队列PriorityQueue来维护一个小根堆，在进入队列时即进行排序，每次只需要从队列中进行取值，不用在进行k个链表头结点的遍历。

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        Queue<ListNode> pq = new PriorityQueue<>((v1, v2) -> v1.val - v2.val);
        for (ListNode node: lists) {
            if (node != null) {
                pq.offer(node);
            }
        }

        ListNode dummyHead = new ListNode(0);
        ListNode tail = dummyHead;
        while (!pq.isEmpty()) {
            ListNode minNode = pq.poll();
            tail.next = minNode;
            tail = minNode;
            if (minNode.next != null) {
                pq.offer(minNode.next);
            }
        }

        return dummyHead.next;
    }
}

复杂度分析：

• 时间复杂度：O(NlogK)，每次维护一个K个元素的小根堆O(logK)，需要遍历N次。
• 空间复杂度：O(K)，使用了固定大小的辅助队列。

逐一合并两条链表

// 合并两条链表
private ListNode merge2Lists(ListNode l1, ListNode l2) {
    ListNode dummyHead = new ListNode(0);
    ListNode tail = dummyHead;
    while (l1 != null && l2 != null) {
        if (l1.val < l2.val) {
            tail.next = l1;
            l1 = l1.next;
        } else {
            tail.next = l2;
            l2 = l2.next;
        }
        tail = tail.next;
    }

    tail.next = l1 == null? l2: l1;

    return dummyHead.next;
}

// 逐一合并
public ListNode mergeKLists(ListNode[] lists) {
    ListNode res = null;
    for (ListNode list: lists) {
        res = merge2Lists(res, list);
    }
    return res;
}

复杂度分析：

• 时间复杂度：O(NK)，需要遍历K次进行两两合并

两两合并链表，对逐一合并两条链表进行优化

以下代码完全参考甜姨题解中的代码：

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists.length == 0) {
            return null;
        }
        int k = lists.length;
        while (k > 1) {
            int idx = 0;
            for (int i = 0; i < k; i += 2) {
                if (i == k - 1) {
                    lists[idx++] = lists[i];
                } else {
                    lists[idx++] = merge2Lists(lists[i], lists[i + 1]);
                }
            }
            k = idx;
        }
        return lists[0];
    }
}