【LeetCode】23. Merge k Sorted Lists 解题报告（Python）

题目分析：

这一题是把n个有序链表合成一条有序链表。（补：由于使用字典每次要比较最小值，时间消耗较长，寻找到了另一种方法，见提交代码2）
1、可以先创建一条新链表，再把n个有序链表的head放入字典，然后选出最小值，把最小的值加入新链表。
2、然后把最小值从字典中删除，同时也把那个节点从小链表中删除，并把下一个节点值加入字典。
3、循环1、2知道字典为空。

代码说明：

1、给字典赋初值（每个链表的第一个元素）

		for i in range(len(lists)):
            if lists[i]:
                dict.update({i: lists[i].val})

2、min(dict, key=dict.get)返回字典最小value对应的key。
3、把最小的值加入新链表，然后把最小值从字典中删除，同时也把那个节点从小链表中删除，并把下一个节点值加入字典。

            head_bf.next = ListNode(min_value)
            head_bf = head_bf.next
            dict.pop(min_key)
            lists[min_key] = lists[min_key].next
             if lists[min_key]:
                dict.update({min_key: lists[min_key].val})

4、return head.next，为了方便使新链表开头为-1，所以返回时要往后移一个节点。

测试代码（非提交代码，提交代码在下面）:

def print_ListNode(head):
    while (True):
        print(head.val)
        if head.next is not None:
            head = head.next
        else:
            break

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

list_node1_1 = ListNode(1)
list_node1_2 = ListNode(4)
list_node1_3 = ListNode(5)
list_node1_1.next = list_node1_2
list_node1_2.next = list_node1_3

list_node2_1 = ListNode(1)
list_node2_2 = ListNode(3)
list_node2_3 = ListNode(4)
list_node2_1.next = list_node2_2
list_node2_2.next = list_node2_3

list_node3_1 = ListNode(2)
list_node3_2 = ListNode(6)
list_node3_1.next = list_node3_2

list_node = [list_node1_1, list_node2_1, list_node3_1]

class Solution:
    def mergeKLists(self, lists):
        head = ListNode(-1);
        dict, head_bf = {}, head
        for i in range(len(lists)):
            if lists[i]:
                dict.update({i: lists[i].val})
        while dict:
            min_key = min(dict, key=dict.get)
            min_value = dict.get(min_key)
            head_bf.next = ListNode(min_value)
            head_bf = head_bf.next
            dict.pop(min_key)
            lists[min_key] = lists[min_key].next
            if lists[min_key]:
                dict.update({min_key: lists[min_key].val})
        return head.next

print_ListNode(Solution().mergeKLists(list_node))    #提交时强删除该行

提交代码:

class Solution:
    def mergeKLists(self, lists):
        head = ListNode(-1);
        dict, head_bf = {}, head
        for i in range(len(lists)):
            if lists[i]:
                dict.update({i: lists[i].val})
        while dict:
            min_key = min(dict, key=dict.get)
            min_value = dict.get(min_key)
            head_bf.next = ListNode(min_value)
            head_bf = head_bf.next
            dict.pop(min_key)
            lists[min_key] = lists[min_key].next
            if lists[min_key]:
                dict.update({min_key: lists[min_key].val})
        return head.next

提交代码2：
基本思想与上面的方法是类似的，这一次做了两点优化：
1、使用[]代替dict
2、不是每次找出最小的，而是直接用sort排序并且使用lambda表达式（python3比较好用的方法10，可参考里面的参考博客）指定以节点值进行排序

class Solution:
    def mergeKLists(self, lists: 'List[ListNode]') -> 'ListNode':
        nums, dum = [], ListNode(0)
        p = dum
        for l in lists:
            while l:
                nums.append(l)
                l = l.next
        for i in sorted(nums, key = lambda l: l.val):
            p.next = i
            p = p.next
        return dum.next