[NeetCode 150] Merge K Sorted Linked Lists

Merge K Sorted Linked Lists

You are given an array of k linked lists lists, where each list is sorted in ascending order.

Return the sorted linked list that is the result of merging all of the individual linked lists.

Example 1:

复制代码
Input: lists = [[1,2,4],[1,3,5],[3,6]]

Output: [1,1,2,3,3,4,5,6]

Example 2:

复制代码
Input: lists = []

Output: []

Example 3:

复制代码
Input: lists = [[]]

Output: []

Constraints:

复制代码
0 <= lists.length <= 1000
0 <= lists[i].length <= 100
-1000 <= lists[i][j] <= 1000

Solution

To take advantage of the feature that each list is sorted in ascending order, it is OK to use O ( number of elements in 2 lists ) O(\text{number of elements in 2 lists}) O(number of elements in 2 lists) two pointers method to merge 2 ordered lists. The overall time complexity will be O ( number of all elements × number of linked lists ) O(\text{number of all elements}\times \text{number of linked lists}) O(number of all elements×number of linked lists).

We can accelerate this process by a simple priority queue, reducing the time complexity to O ( n log ⁡ n ) O(n\log n) O(nlogn), where n n n denotes the total number of all elements in linked lists.

However, by using hash, or bucket sort, wo can achieve O ( V ) O(V) O(V) time complexity, where V V V denotes the size of the discrete value domain of elements, and V ≤ n V\le n V≤n. Additionally, it does not require the given linked lists to be ordered.

To be more detailed, we can use a dictionary to store the nodes of different values and link them together in the end. The code might look like:

python 复制代码
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:    
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        buket = {number:None for number in range(-1000, 1001)}
        for node in lists:
            while node.next:
                buket[node.val].append(node)
                node = node.next
            buket[node.val].append(node)
        preNode = None
        rootNode = None
        for value in buket.values():
            for node in value:
                if preNode:
                    preNode.next = node
                else:
                    rootNode = node
                preNode = node
        return rootNode

However, that is not perfect! As the elements are all stored in linked lists, we only need to store the head and tail nodes of each value. When a new element coming in, we just link it as the new head/tail. In the end, we only need to link head and tail of different values' linked list one by one. This method only takes O ( V ) O(V) O(V) extra space and O ( V ) O(V) O(V) time to link.

Code

Please ignore the typo of "bucket".

python 复制代码
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:    
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        head_buket = {}
        tail_buket = {}
        for node in lists:
            while True:
                if node.val not in tail_buket:
                    tail_buket[node.val] = node
                nextNode = node.next
                node.next = head_buket.get(node.val, None)
                head_buket[node.val] = node
                node = nextNode
                if node is None:
                    break
        preNode = None
        rootNode = None
        for key in range(-1000, 1001):
            if key in head_buket:
                if preNode is None:
                    rootNode = head_buket[key]
                else:
                    preNode.next = head_buket[key]
                preNode = tail_buket[key] 
        return rootNode
相关推荐
拓端研究室2 小时前
视频讲解:门槛效应模型Threshold Effect分析数字金融指数与消费结构数据
前端·算法
随缘而动,随遇而安4 小时前
第八十八篇 大数据中的递归算法:从俄罗斯套娃到分布式计算的奇妙之旅
大数据·数据结构·算法
郭庆汝5 小时前
pytorch、torchvision与python版本对应关系
人工智能·pytorch·python
IT古董5 小时前
【第二章:机器学习与神经网络概述】03.类算法理论与实践-(3)决策树分类器
神经网络·算法·机器学习
Alfred king7 小时前
面试150 生命游戏
leetcode·游戏·面试·数组
水木兰亭8 小时前
数据结构之——树及树的存储
数据结构·c++·学习·算法
思则变8 小时前
[Pytest] [Part 2]增加 log功能
开发语言·python·pytest
漫谈网络8 小时前
WebSocket 在前后端的完整使用流程
javascript·python·websocket
Jess078 小时前
插入排序的简单介绍
数据结构·算法·排序算法
老一岁8 小时前
选择排序算法详解
数据结构·算法·排序算法