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 = Noneclass 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试着提交了上述代码，结果居然比我手写的二路归并思想的算法效率还低。。。改天我要自己写一个- -