LeetCode 合并K个排序链表 [***标记****]

合并K个排序链表

题目描述

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

解题方法

（错误方法）方法一：

超时了…

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

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        if not lists: return None
        res = ListNode(0)
        head=res
        while True:
            list_val = []
            for listnode in lists:
                if listnode: list_val.append(listnode.val)
                else: list_val.append(None)
            if None in list_val:
                l_copy = list_val.copy()
                while None in l_copy: l_copy.remove(None)
                #print("l_copy:", l_copy)
                if not l_copy : break
                min_index = list_val.index(min(l_copy))
            else:
                min_index = list_val.index(min(list_val))

            #print(min_index, list_val)

            res.next = lists[min_index]
            if lists[min_index]: lists[min_index] = lists[min_index].next
            res = res.next
        
        return head.next            

（错误方法修正版）方法二：

    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        if not lists: return None
        res = ListNode(0)
        head=res
        while True:
            list_val = []
            list_no_none = []
            for listnode in lists:
                if listnode: 
                    list_val.append(listnode.val)
                    list_no_none.append(listnode.val)
                else: list_val.append(None)
            if None in list_val:
                if not list_no_none : break
                min_index = list_val.index(min(list_no_none))
            else:
                min_index = list_val.index(min(list_val))

            #print(min_index, list_val)

            res.next = lists[min_index]
            if lists[min_index]: lists[min_index] = lists[min_index].next
            res = res.next        
        return head.next   

(正确方法) 方法三（修正前面的算法）：

class Solution:
    def get_min_temp(self,lists,val_list):
    
        if val_list==[]:
            return lists,None,val_list
        min_val = min(val_list)
        i = val_list.index(min_val)
        node = lists[i]
        if lists[i].next:
            val_list[i]=lists[i].next.val
            lists[i] = lists[i].next
            return lists,node,val_list
        else:
            val_list = val_list[:i]+val_list[i+1:]
            lists = lists[:i]+lists[i+1:]
            return lists,node,val_list
        
    def mergeKLists(self, lists):

        for i in range(len(lists)):
            try:
                lists.remove(None)
            except:
                pass 
        if lists==[]:
            return None
        val_list = []
        for i in range(len(lists)):
            val_list.append(lists[i].val) 
        head = ListNode(0)
        temp=head
        Flag = True
        while Flag:
                lists,node,val_list = self.get_min_temp(lists,val_list)
                if node:
                    temp.next=node
                    temp = temp.next
                else:
                    Flag = False
        return head.next

（正确方法——分治法）方法四：

多路归并排序
前面有有一道两个有序ListNode合并的编程题，基于这个，考虑将lists中的listnode先两两合并，对合并后新的lists，再次进行两两合并，循环进行，知道lists的长度为1为止。

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

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        if not lists : return 
        if len(lists)==1: return lists[0]
        while len(lists)>1:
            i , j = 0 , len(lists)-1
            while(i<j):
                lists[i] = self.mergeTwoLists(lists[i], lists[j])
                i+=1
                j-=1
                if i==j: break
            lists = lists[0:len(lists)/2] if len(lists)%2==0 else lists[0:len(lists)//2+1]
        return lists[0]
   
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l2: return l1
        if not l1: return l2
        if l1.val<l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2