合并两个及以上有序链表问题

合并两个及以上有序链表问题

作者：Grey

原文地址:

博客园：合并两个及以上有序链表问题

CSDN：合并两个及以上有序链表问题

合并两个有序链表

题目描述见：LeetCode 21. Merge Two Sorted Lists

主要思路

首先判断list1和list2的第一个元素，谁小，谁就是最后要返回的链表的头节点，如果list1和list2的第一个元素相等，随便取哪个都可以。

这样，我们就设置好了要返回链表的头节点，假设头节点是newHead，

依次移动list1和list2指针，谁小，谁就接入进来。依次操作，直到两个链表都遍历完毕为止。

此外，有个显而易见的结论：如果list1和list2有一个链表不为空，则返回那个不为空的链表即可

完整代码

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }
        ListNode newHead = list1.val > list2.val ? list2 : list1;
        if (newHead == list1) {
            list1 = list1.next;
        } else {
            list2 = list2.next;
        }
        ListNode cur = newHead;
        while (list1 != null && list2 != null) {
            if (list1.val > list2.val) {
                cur.next = list2;
                cur = cur.next;
                list2 = list2.next;
            } else {
                cur.next = list1;
                cur = cur.next;
                list1 = list1.next;
            }
        }
        while (list1 != null) {
            cur.next = list1;
            cur = cur.next;
            list1 = list1.next;
        }
        while (list2 != null) {
            cur.next = list2;
            cur = cur.next;
            list2 = list2.next;
        }
        return newHead;
    }
}

合并多个有序链表

题目描述见：LeetCode 23. Merge k Sorted Lists

主要思路

准备一个小根堆，并把每个链表的头节点加入到小根堆中，此时，小根堆堆顶弹出的节点一定是最后生成链表的头节点。

假设链表为：list1,list2...listN

第一步，先将 list1,list2...listN 的头节点 L1H,L2H...LNH 加入小根堆；

第二步，从小根堆堆顶弹出一个元素，作为最后链表的头节点；

第三步，第二步中弹出节点所在的链表，假设是i号链表，那么就找弹出节点的下一个位置（假设为 X ）再和小根堆堆顶元素比较，会有三种情况：

1、如果 X 比堆顶元素大，则堆顶元素弹出，X 进入小根堆；

2、如果 X 比堆顶元素小，则直接不需要进入堆顶，作为结果链表下一个位置；

3、如果 X 是 null，则说明这个节点所在链表已处理完毕，可以直接弹出堆中下一个节点。

完整代码

class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (null == lists || lists.length == 0) {
            return null;
        }
        if (lists.length == 1) {
            return lists[0];
        }
        PriorityQueue<ListNode> heap = new PriorityQueue<>((o1, o2) -> (o1.val - o2.val));
        for (ListNode list : lists) {
            if (list != null) {
                heap.offer(list);
            }
        }
        ListNode newHead = heap.poll();
        ListNode cur = newHead;
        while (!heap.isEmpty()) {
            ListNode next = cur.next;
            if (next == null) {
                // 某个链表走到头了
                cur.next = heap.poll();
                cur = cur.next;
            } else {
                if (next.val <= heap.peek().val) {
                    cur = cur.next;
                } else {
                    cur.next = heap.poll();
                    cur = cur.next;
                    heap.offer(next);
                }
            }
        }
        return newHead;
    }
}

更多

算法和数据结构学习笔记

算法和数据结构学习代码