leetcode23_Merge k Sorted Lists

一.问题描述

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

合并k条有序链表，返回一条有序链表

二.算法思想

有两种思路：

1）利用二路归并的思想，将k条有序链条两两进行二路归并，一共需要logk次合并后得到最终链表。显然，可以通过递归来实现 ，既然说到递归，那么应该也可以考虑用时间换空间；

2）k个指针顺序遍历k条有序链表，每次取出来的节点组成一个堆（这里考虑用堆，每次进行对排序只需要logk的复杂度，只需要取最大or最小值时要考虑用堆啊！！！不需要完全有序！），每次取堆顶接到输出链表中，并继续遍历k条有序链表。

实现时注意，这种单链表的操作加上头结点会比较好处理（避免过多的判断语句）。

三.算法实现

二路归并的思想，没有通过递归来实现，代码如下：

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution(object):
    def merge2Lists(self, listNodeA, listNodeB):
        i = listNodeA
        j = listNodeB
        return_listNode = ListNode(0)  # return node with a header
        return_aid = return_listNode
        while i != None and j != None:
            if i.val < j.val:
                return_aid.next = i
                i = i.next
            else:
                return_aid.next = j
                j = j.next
            return_aid = return_aid.next
        if i != None:
            return_aid.next = i
        elif j != None:
            return_aid.next = j
        return return_listNode.next

    def mergeKLists(self, lists):
        """
        :type lists: List[ListNode]
        :rtype: ListNode
        """
        k = len(lists)
        if k == 0: return []
        j = 1
        while j < k :
            for i in range(0, k, 2 * j):
                lists[i] = self.merge2Lists(lists[i], lists[i + j]) if i + j < k else lists[i]
            j *= 2
        return lists[0]

这个算法效率并不高，可是我看了下代码本身并没发现很多可优化的地方啊- -

用堆实现的算法参见网站http://www.jiuzhang.com/solutions/merge-k-sorted-lists/ 代码如下：

class Solution:
    """
    @param lists: a list of ListNode
    @return: The head of one sorted list.
    """
    def mergeKLists(self, lists):
        # write your code here
        self.heap = [[i, lists[i].val] for i in range(len(lists)) if lists[i] != None]
        self.hsize = len(self.heap)
        for i in range(self.hsize - 1, -1, -1):
            self.adjustdown(i)
        nHead = ListNode(0)
        head = nHead
        while self.hsize > 0:
            ind, val = self.heap[0][0], self.heap[0][1]
            head.next = lists[ind]
            head = head.next
            lists[ind] = lists[ind].next
            if lists[ind] is None:
                self.heap[0] = self.heap[self.hsize-1]
                self.hsize = self.hsize - 1
            else:
                self.heap[0] = [ind, lists[ind].val]
            self.adjustdown(0)
        return nHead.next

    def adjustdown(self, p):
        lc = lambda x: (x + 1) * 2 - 1
        rc = lambda x: (x + 1) * 2
        while True:
            np, pv = p, self.heap[p][1]
            if lc(p) < self.hsize and self.heap[lc(p)][1] < pv:
                np, pv = lc(p), self.heap[lc(p)][1]
            if rc(p) < self.hsize and self.heap[rc(p)][1] < pv:
                np = rc(p)
            if np == p:
                break
            else:
                self.heap[np], self.heap[p] = self.heap[p], self.heap[np]
                p = np

但是实际上我用leetcode试着提交了上述代码，结果居然比我手写的二路归并思想的算法效率还低。。。改天我要自己写一个- -