【Leetcode】Merge k Sorted Lists

最新推荐文章于 2025-09-07 20:32:33 发布

yyz20002008

最新推荐文章于 2025-09-07 20:32:33 发布

阅读量126

点赞数

文章标签： java leetcode arraylist ListNode

本文介绍了两种高效合并K个已排序链表的方法：一种利用二分法递归合并，时间复杂度为O(nklogk)，空间复杂度为O(logk)；另一种使用最小堆进行合并，时间复杂度同样为O(nklogk)，但空间复杂度降低到O(k)。

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Java:

http://blog.youkuaiyun.com/linhuanmars/article/details/19899259

1. 二分法时间：O(nklogk) 空间：O(logk)

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeKLists(List<ListNode> lists) {
        if(lists==null||lists.size()==0)
        return null;
        return helper(lists,0,lists.size()-1);
    }
    private ListNode helper(List<ListNode> list, int l,int r)
    {
        if(l<r)
        {
            int m=(l+r)/2;
            return merge(helper(list,l,m),helper(list,m+1,r));
        }
        else return list.get(l);
    }
    private ListNode merge(ListNode l1, ListNode l2)
    {
        ListNode dummy= new ListNode(0);
        dummy.next=l1;
        ListNode cur=dummy;
        
        while(l1!=null&&l2!=null){
           if(l1.val<l2.val){
               l1=l1.next;
           }
           else{
               ListNode next=l2.next;
               cur.next=l2;
               l2.next=l1;
               l2=next;
               
           }
           cur=cur.next;
        }
        if(l2!=null)
        cur.next=l2;
        return dummy.next;
    }
}

2.堆，还不太熟，时间复杂度是O(nklogk)。空间复杂度是堆的大小，即为O(k)

public ListNode mergeKLists(ArrayList<ListNode> lists) {  
    PriorityQueue<ListNode> heap = new PriorityQueue<ListNode>(10,new Comparator<ListNode>(){  
            @Override  
            public int compare(ListNode n1, ListNode n2)  
            {  
                return n1.val-n2.val;  
            }  
        });  
    for(int i=0;i<lists.size();i++)  
    {  
        ListNode node = lists.get(i);   
        if(node!=null)  
        {  
            heap.offer(node);  
        }  
    }  
    ListNode head = null;  
    ListNode pre = head;  
    while(heap.size()>0)  
    {  
        ListNode cur = heap.poll();  
        if(head == null)  
        {  
            head = cur;  
            pre = head;  
        }  
        else  
        {  
            pre.next = cur;  
        }  
        pre = cur;  
        if(cur.next!=null)  
            heap.offer(cur.next);  
    }  
    return head;  
}