leetcode#23

==============================================================================

【id】#23

【title】 Merge k Sorted Lists

【description】

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

Example:

Input:
[
1->4->5,
1->3->4,
2->6
]
Output: 1->1->2->3->4->4->5->6

【idea】
最小堆算法。

先将每个链表的第一个节点值以及节点（val，node）放入最小堆里，会自动排序。然后pop出最小的节点放入结果中，然后将最小节点的下一个节点放入堆中继续操作。

【code】

# 最小堆,使用heapq模块
import heapq
class Solution(object):
    def mergeKLists(self, lists):
        heap = []
        for lis in lists:
            if lis: heapq.heappush(heap, (lis.val,lis))
        res = tmp =ListNode(0)
        while heap:
            min_node = heapq.heappop(heap)[1]
            tmp.next = min_node
            tmp = tmp.next
            if min_node.next:
                heapq.heappush(heap,(min_node.next.val,min_node.next))
        return res.next

【idea】

暴力方法
将链表中的所有值放入list中，之后依次读取排好序的列表值，建立链表。

【code】

# brute force

# 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
        """
        tmp = []
        res = pointer = ListNode(0)
        for x in lists:
            while x:
                tmp.append(x.val)
                x = x.next
        for v in sorted(tmp):
            pointer.next = ListNode(v)
            pointer = pointer.next
        return res.next
            

【idea】

分治法.
将k个链表分成k/2部分，每次两两进行比较。

【code】

# divide and conque
class Solution(object):
    def mergeKLists(self, lists):
        num = 1
        length = len(lists)
        if length == 0 : return lists
        while num < length:
            for i in range(0, length-num, 2*num):
                lists[i] = self.mergeLists(lists[i], lists[i + num])
            num *= 2
        return lists[0] 
            
    def mergeLists(self,l1,l2):
        res = tmp = ListNode(0)
        while l1 and l2:
            if l1.val < l2.val:
                tmp.next = l1
                l1 = l1.next
            else:
                tmp.next = l2
                l2 = l2.next
            tmp = tmp.next
        if l1!= None: tmp.next = l1
        if l2!= None: tmp.next = l2
        return res.next