leetcode第23题——***Merge k Sorted Lists

题目

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

思路

将数组中的k个有序链表归并成一个有序链表，并分析时间复杂度。该题可以在第22题-"merge two sorted lists"的基础上设计算法。

一开始想到遍历数组的k-1个链表，将第一个链表与第二个链表合并成一个新链表，然后第三个链表再跟这个新链表合并成新链表，以此类推......假设链表长度最长为n，则这样设计出来的算法时间复杂度为O(n*k)，提交报超时错误。

改变思路，不要用单一遍历方式。可以递归归并数组中的k个链表，将其分割成k/2大小的数组归并，然后再分成k/2^2大小的数组归并......这样递归归并的时间复杂度为O(logk)，总时间复杂度为O(n*logk)

代码

Python

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        if(len(lists) == 0):
            return
        return self.merge(lists,0,len(lists) - 1)
        
    def merge(self,lists,start,end):
        if(start == end):
            return lists[start]
            
        if(end - start == 1):
            return self.mergeTwoLists(lists[start],lists[end])
            
        mid = start + (end - start)/2
        return self.mergeTwoLists(self.merge(lists,start,mid),self.merge(lists,mid+1,end))
            
    def mergeTwoLists(self, l1, l2):  
        """ 
        :type l1: ListNode 
        :type l2: ListNode 
        :rtype: ListNode 
        """  
        head = ListNode(0)  
        cur = head  
          
        while(l1 != None and l2 != None):  
            #遍历l1和l2的节点并比较大小，将小的放入目标链表中，cur为游标  
            if(l1.val < l2.val):  
                cur.next = l1  
                l1 = l1.next  
            else:  
                cur.next = l2  
                l2 = l2.next  
            cur.next.next = None  
            cur = cur.next  
              
        #比较完l1和l2后还有剩余节点  
        if(l1 != None):  
            cur.next = l1  
        else:  
            cur.next = l2  
              
        return head.next

Java

/**
 * 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.length == 0)
			return null;
		return merge(lists, 0, lists.length - 1);//另外定义了一个根据数组下标merge的函数
	}

	public ListNode merge(ListNode[] lists, int start, int end) {
		if (start == end)
			return lists[start];
		if (end - start == 1)
			return mergeTwoLists(lists[start], lists[end]);

		int mid = start + (end - start) / 2;
		//递归merge，merge k/2个，k/2^2,k/2^3...直到merge两个或一个
		return mergeTwoLists(merge(lists, start, mid),merge(lists, mid + 1, end));
	}

	public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
		ListNode head = new ListNode(0);
		ListNode cur = head;
		// 遍历l1和l2的节点并比较大小，cur代表当前节点
		while (l1 != null && l2 != null) {
			if (l1.val < l2.val) {
				cur.next = l1;
				l1 = l1.next;
			} else {
				cur.next = l2;
				l2 = l2.next;
			}
			cur.next.next = null;// 可减少链表大小，提高效率
			cur = cur.next;
		}

		// 比较完l1和l2的节点后还有剩余节点
		if (l1 != null)
			cur.next = l1;
		else
			cur.next = l2;

		return head.next;
	}
}