合并k个排序链表

最新推荐文章于 2024-03-27 14:57:56 发布

MoForest

最新推荐文章于 2024-03-27 14:57:56 发布

阅读量187

点赞数

分类专栏： leetcode

本文链接：https://blog.csdn.net/MoForest/article/details/84777089

版权

leetcode 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

问题描述

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

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

我的答案

自己写的答案和官方的第二个解答方案是一致的

思想

因为链表是有序的，所以链表的前面的元素一定是小的，由此我们可以首先遍历所有链表的第一个节点的值，将其中最小的值的节点放入结果集当中，然后那个节点的链表向后移动，由此循环，知道所有链表的所有节点全部遍历完成。

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode node = new ListNode(0);
        node.next = null;
        ListNode result = node;
        int s = 0;
        int curVal = Integer.MAX_VALUE;
        while(lists.length != 0){
            curVal = Integer.MAX_VALUE;
            for(int i = 0; i < lists.length; i++){
                if(lists[i] == null){
                    lists[i] = lists[lists.length-1];
                    lists = Arrays.copyOf(lists,lists.length-1);
                    i--;
                    continue;
                }
                if(lists[i].val < curVal){
                    curVal = lists[i].val;
                    s = i;
                }
            }
            if(lists.length == 0){
                break;
            }
            node.next = lists[s];
            node = node.next;
            if(lists[s] != null){
                lists[s] = lists[s].next;
            }
        
        }
        return result.next;
    }
}

复杂度

需要O(KN)时间，N是所有的节点数，k是链表数，所以时间很慢，最后的结果只比答案中3%的人快，可以说是最垃圾的算法了。

官方答案

1. 暴力法

将所有节点放入到一个数组中，然后使用库函数排序，最后将数组中的节点依次放入到结果集链表中。

2. 依次遍历

与我的答案相同

3. 通过优先队列优化方法2

优先队列可以构建出一个最小堆，重载优先队列的重载器给出节点的值的比较方法。

思想

首先遍历链表数组，将链表放入，然后开始存入结果集，将优先队列的根节点取出放入结果集，每当放入一个节点到结果集，将当前节点向后移动，然后将移动后的节点再放入优先队列中，直到优先队列为空。

代码

public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        ListNode head = new ListNode(-1);
        Queue<ListNode> listNodes = new PriorityQueue<>(new Comparator<ListNode>() {
            @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;
            }
        });
        for(int i = 0; i < lists.length; ++i){
            if(lists[i] != null) {
                listNodes.offer(lists[i]);
                lists[i] = lists[i].next;
            }
        }
        ListNode res = head;
        while (!listNodes.isEmpty()){
            ListNode tmp = listNodes.poll();
            head.next = tmp;
            head =head.next;
            tmp = tmp.next;
            if(tmp != null) listNodes.offer(tmp);
        }
        return res.next;
    }

}

这个方法也可以自己写一个最小堆来进行优化。

时间复杂度

时间复杂度为O(Nlogk)相比与之前的方法快了很多，提交后比leetcode上45%的答案要快，这个时间复杂度理论上已经是最优得了。

4. 依次合并

思想

利用之前做过的两个排序链表的合并的答案得到这个算法，依次遍历链表数组，将链表两两合并，这个方法的时间复杂度也是O(kN)的时间，但是可以两两合并的话，就可以使用归并排序来进行优化。

代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) return null;
        return mergeKLists(lists, 0, lists.length - 1);
    }
    
    private ListNode mergeKLists(ListNode[] lists, int start, int end) {
        if (start == end) return lists[start];
        if (start + 1 == end) return mergeTwoLists(lists[start], lists[end]);
        
        int mid = (start + end) / 2;
        ListNode result1 = mergeKLists(lists, start, mid);
        ListNode result2 = mergeKLists(lists, mid + 1, end);
        return mergeTwoLists(result1, result2);
    }
    
    private ListNode mergeTwoLists(ListNode head1, ListNode head2) {
        ListNode result = new ListNode(0), pointer = result;
        while (head1 != null && head2 != null) {
            if (head1.val <= head2.val) {
                pointer.next = new ListNode(head1.val);
                head1 = head1.next;
            } else {
                pointer.next = new ListNode(head2.val);
                head2 = head2.next;
            }
            pointer = pointer.next;
        }
        if (head1 == null) 
            pointer.next = head2;
        else pointer.next = head1;
        return result.next;
    }
   

}

但是这个答案在leetcode上是最快的，应该是官方的数据结构的问题导致的，所以只做参考。

5. 归并排序

思想

这也是最优解之一，将数组两两合并为一个链表，迭代到最后归并成一个链表

我的代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists==null||lists.length==0)return null;
        int i = 1;
        while(i < lists.length){
            for(int j = 0; j < lists.length - i; j+=2*i){
                lists[j] = mergeTwoLists(lists[j],lists[j+i]);
            }
            i*=2;
        }
        return lists[0];
    }
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode p=l1;
        ListNode q=l2;
        ListNode t=new ListNode(-1);
        t.next=null;
        l1=t;
        
        while(p!=null&&q!=null){
            if(p.val<=q.val){
                t.next=p;
                t=t.next;
                p=p.next;
            }
            else{
                t.next=q;
                t=t.next;
                q=q.next;
            }
            
        }
        
        if(q==null){
            t.next=p;
        }
        else{
            t.next=q;
        }
        return l1.next;
    }
}