[剑指offer][JAVA]面试题[第23题][合并K个排序链表][分治][优先队列]

最新推荐文章于 2023-12-24 10:35:21 发布

CryptWinter

最新推荐文章于 2023-12-24 10:35:21 发布

阅读量296

点赞数

分类专栏：非0即1 刷题文章标签：链表算法 java

本文链接：https://blog.csdn.net/dadongwudi/article/details/105517489

版权

刷题同时被 2 个专栏收录

249 篇文章 2 订阅

订阅专栏

非0即1

239 篇文章 1 订阅

订阅专栏

【问题描述】23.合并K个排序链表

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。
示例:
输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

【解答思路】

1. 两两合并

public class Solution2 {

    public ListNode mergeKLists(ListNode[] lists) {
        int size = lists.length;
        if (size == 0) {
            return null;
        }

        ListNode res = lists[0];
        for (int i = 1; i < size; i++) {
            if (lists[i] != null) {
                res = mergeTwoSortLinkedList(res, lists[i]);
            }
        }
        return res;
    }

    private ListNode mergeTwoSortLinkedList(ListNode list1, ListNode list2) {
        ListNode dummyNode = new ListNode(-1);
        ListNode p1 = list1;
        ListNode p2 = list2;
        ListNode curNode = dummyNode;
        // 两者都不为空的时候，才有必要进行比较
        while (p1 != null && p2 != null) {
            if (p1.val < p2.val) {
                // 指针修改发生在这里
                curNode.next = p1;
                p1 = p1.next;
            } else {
                // 指针修改发生在这里
                curNode.next = p2;
                p2 = p2.next;
            }
            curNode = curNode.next;
        }
        // 跳出循环是因为 p1 == null 或者 p2 == null
        if (p1 == null) {
            curNode.next = p2;
        }
        if (p2 == null) {
            curNode.next = p1;
        }
        return dummyNode.next;
    }
}

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/

2. 分治法

想清楚数据结构 ListNode[] 只存了头节点
1、先一分为二，分别“递归地”解决了与原问题同结构，但规模更小的两个子问题；
2、再考虑如何合并，这个合并的过程也是一个递归方法（同 LeetCode 第 21 题：合并两个有序链表）。
时间复杂度：O(NlogN)

import java.util.Comparator;
import java.util.PriorityQueue;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
//测试使用
    ListNode(Integer[] nums) {
        ListNode currNode = this;
        currNode.val = nums[0];
        for (int i = 1; i < nums.length; i++) {
            currNode.next = new ListNode(nums[i]);
            currNode = currNode.next;
        }
    }
//测试使用
    @Override
    public String toString() {
        ListNode currNode = this;
        StringBuilder s = new StringBuilder();
        while (currNode != null) {
            s.append(currNode.val);
            s.append(" -> ");
            currNode = currNode.next;
        }
        // 最后添加一个 NULL 标志表示添加到末尾了
        s.append("NULL");
        return s.toString();
    }
}

public class Solution {

    public ListNode mergeKLists(ListNode[] lists) {
        int len = lists.length;
        if (len == 0) {
            return null;
        }
        return mergeKLists(lists, 0, len - 1);
    }

    public ListNode mergeKLists(ListNode[] lists, int l, int r) {
        // 思考这里为什么取等于？这是因为根据下文对 mergeKLists 的递归调用情况，区间最窄的时候，只可能是左右端点重合
        if (l == r) {
            return lists[l];
        }
        int mid = (r - l) / 2 + l;
        ListNode l1 = mergeKLists(lists, l, mid);
        ListNode l2 = mergeKLists(lists, mid + 1, r);
        return mergeTwoSortedListNode(l1, l2);
    }

    private ListNode mergeTwoSortedListNode(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }
        if (l1.val < l2.val) {
            l1.next = mergeTwoSortedListNode(l1.next, l2);
            return l1;
        }
        l2.next = mergeTwoSortedListNode(l1, l2.next);
        return l2;
    }
}

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/

3. 贪心算法、优先队列（最小堆）

时间复杂度：O(NlogN) 空间复杂度：O(N)

import java.util.Comparator;
import java.util.PriorityQueue;

class ListNode {
    int val;
    ListNode next;

    ListNode(int x) {
        val = x;
    }
//n条链表合成一条 测试使用
    ListNode(Integer[] nums) {
        ListNode currNode = this;
        currNode.val = nums[0];
        for (int i = 1; i < nums.length; i++) {
            currNode.next = new ListNode(nums[i]);
            currNode = currNode.next;
        }
    }
//测试使用 
    @Override
    public String toString() {
        ListNode currNode = this;
        StringBuilder s = new StringBuilder();
        while (currNode != null) {
            s.append(currNode.val);
            s.append(" -> ");
            currNode = currNode.next;
        }
        // 最后添加一个 NULL 标志表示添加到末尾了
        s.append("NULL");
        return s.toString();
    }
}

public class Solution {

    public ListNode mergeKLists(ListNode[] lists) {
        int len = lists.length;
        if (len == 0) {
            return null;
        }
        PriorityQueue<ListNode> priorityQueue = new PriorityQueue<>(len, Comparator.comparingInt(a -> a.val));
        /*
        @Override
            public int compare(ListNode o1, ListNode o2) {
                if (o1.val < o2.val) return -1;
                else if (o1.val == o2.val) return 0;
                else return 1;
            }
        */
        ListNode dummyNode = new ListNode(-1);
        ListNode curNode = dummyNode;
        for (ListNode list : lists) {
            if (list != null) {
                // 这一步很关键，不能也没有必要将空对象添加到优先队列中
                priorityQueue.add(list);
            }
        }
        while (!priorityQueue.isEmpty()) {
            // 优先队列非空才能出队
            ListNode node = priorityQueue.poll();
            // 当前节点的 next 指针指向出队元素
            curNode.next = node;
            // 当前指针向前移动一个元素，指向了刚刚出队的那个元素
            curNode = curNode.next;
            if (curNode.next != null) {
                // 只有非空节点才能加入到优先队列中
                priorityQueue.add(curNode.next);
            }
        }
        return dummyNode.next;
    }

    public static void main(String[] args) {
        Integer[] nums1 = {1, 4, 5};
        Integer[] nums2 = {1, 3, 4};
        Integer[] nums3 = {2, 6};
        ListNode head1 = new ListNode(nums1);
        ListNode head2 = new ListNode(nums2);
        ListNode head3 = new ListNode(nums3);
        ListNode[] lists = new ListNode[3];
        lists[0] = head1;
        lists[1] = head2;
        lists[2] = head3;
        Solution solution = new Solution();
        ListNode mergeKLists = solution.mergeKLists(lists);
        System.out.println(mergeKLists);
    }
}

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/

【总结】

1.递归思想

1、数组的排序方法要很清楚，这一点是迁移到链表上，发现只有归并排序适用；
2、归并排序其实就是分而治之；
3、还要清楚两个排序链表是怎么合并的（可以递归也可以非递归用双指针去穿针引线）。
如果这些所以就很自然迁移到合并 K 个排序链表。

2.链表

“递归”、“分治”
“穿针引线” 优先队列堆

3.PriorityQueue

1>PriorityQueue是一种无界的，线程不安全的队列（无锁）
2>PriorityQueue是一种通过数组实现的，并拥有优先级的队列
3>PriorityQueue存储的元素要求必须是可比较的对象Comparator（数量+比较对象），如果不是就必须明确指定比较器

优先队列java解析与用法：https://www.jb51.net/article/84371.htm
优先队列源码解析：https://www.cnblogs.com/CarpenterLee/p/5488070.html
解题解析：https://leetcode-cn.com/problems/merge-k-sorted-lists/solution/tan-xin-suan-fa-you-xian-dui-lie-fen-zhi-fa-python/

异度侵入

CryptWinter

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
[剑指offer][JAVA]面试题[第23题][合并K个排序链表][分治][优先队列]

【问题描述】23.合并K个排序链表合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。示例:输入:[  1->4->5,  1->3->4,  2->6]输出: 1->1->2->3->4->4->5->6【解答思路】1. 两两合并p...
复制链接

扫一扫