[Serie Leetcode] [algoritmo] Lista de combinación de tipo [difícil] K

tema:

enlaces a los temas:  https://leetcode-cn.com/problems/merge-k-sorted-lists/

 

Ideas de resolución de problemas:

Método a: la comparación de cada (O (kN))

Cada ciclo de la comparación de los valores de todos los nodos en la primera lista, y luego toma un valor mínimo, la lista final como el siguiente valor de nodo

Repetir el ciclo hasta que todas las listas se añaden a la lista final, el bucle termina

 

Método dos: Violencia (O (NlogN))

En primer lugar los valores de la lista en una matriz y, a continuación, la clasificación, utilizando la matriz ordenada, una lista enlazada a reconstruir

 

Método tres: la comparación de cada cola de prioridad + (O (Nlogk))

Sustancialmente el mismo método, pero utilizando una cola de prioridad auxiliar, reduciendo el número de ciclos del proceso de comparación, el rendimiento en gran medida optimizado

 

la implementación del código:

Método uno:

# 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:
        head_save = head = ListNode(0)
        flag = True
        while flag:
            flag = False
            min_val, min_idx = float('inf'), 0
            for index in range(len(lists)):
                if not lists[index]:
                    continue
                    
                flag = True
                if lists[index].val < min_val:
                    min_val = lists[index].val
                    min_idx = index

            if flag:
                head.next = ListNode(min_val)
                head = head.next
                lists[min_idx] = lists[min_idx].next
                
        return head_save.next
                

 

Segundo método:

# 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:
        val_lst = []
        for curr_list in lists:
            while curr_list:
                val_lst.append(curr_list.val)
                curr_list = curr_list.next
                
        head_save = head = ListNode(0)
        for curr_val in sorted(val_lst):
            head.next = ListNode(curr_val)
            head = head.next
            
        return head_save.next

 

Método tres:

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

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        head_save = head = ListNode(0)
        pq = queue.PriorityQueue()
        for index, curr_list in enumerate(lists):
            if curr_list:
                pq.put((curr_list.val, index))
                
        while not pq.empty():
            curr_val, curr_index = pq.get()
            head.next = ListNode(curr_val)
            head = head.next
            lists[curr_index] = lists[curr_index].next
            if lists[curr_index]:
                pq.put((lists[curr_index].val, curr_index))
                
        return head_save.next