使用最小堆合并 K 个已排序链表的 Javascript 程序 – 第 2 组

给定k个大小为n的链表，每个链表按非降序排序，将它们合并为一个排序（非降序）链表，并将排序后的链表打印为输出。
例子：

Input: k = 3, n =  4
list1 = 1->3->5->7->NULL
list2 = 2->4->6->8->NULL
list3 = 0->9->10->11->NULL

Output: 0->1->2->3->4->5->6->7->8->9->10->11
Merged lists in a sorted order 
where every element is greater 
than the previous element.

Input: k = 3, n =  3
list1 = 1->3->7->NULL
list2 = 2->4->8->NULL
list3 = 9->10->11->NULL

Output: 1->2->3->4->7->8->9->10->11
Merged lists in a sorted order 
where every element is greater 
than the previous element.

资料来源：合并 K 排序的链表 |方法二

这篇文章的方法 3中讨论了该问题的有效解决方案。

方法：此解决方案基于用于解决此处讨论的“合并 k 个排序数组”问题的MIN HEAP方法。
MinHeap： Min-Heap 是一棵完全二叉树，其中每个内部节点中的值小于或等于该节点子节点中的值。将堆的元素映射到数组中很简单：如果一个节点存储在索引 k 处，那么它的左子节点存储在索引 2k + 1 处，其右子节点存储在索引 2k + 2 处。

1. 创建一个最小堆并插入所有“k”链表的第一个元素。
2. 只要 min-heap 不为空，请执行以下步骤：
   • 删除最小堆的顶部元素（这是最小堆中所有元素中的当前最小值）并将其添加到结果列表中。
   • 如果在上一步弹出的元素旁边存在一个元素（在同一个链表中），则将其插入最小堆。
3. 返回合并列表的头节点地址。

下面是上述方法的实现：

Javascript

// Javascript implementation to merge
// k sorted linked lists using MIN HEAP method
class Node
{
    constructor(data)
    {
        this.data = data;
        this.next = null;
    }
}
  
// Function to merge k sorted 
// linked lists
function mergeKSortedLists(arr, k)
{
    let head = null, last = null;
   
    // priority_queue 'pq' implemeted
    // as min heap with the help of 
    // 'compare' function
    let pq = [];
   
    // Push the head nodes of all
    // the k lists in 'pq'
    for (let i = 0; i < k; i++)
        if (arr[i] != null)
            pq.push(arr[i]);
           
    pq.sort(function(a, b)
    {
        return a.data - b.data;
    });
          
    // loop till 'pq' is not empty
    while (pq.length != 0)
    {        
        // Get the top element of 'pq'
        let top = pq[0];
        pq.shift();
   
        // Check if there is a node next 
        // to the 'top' node in the list 
        // of which 'top' node is a member
        if (top.next != null)
              
        // Push the next node in 'pq'
        pq.push(top.next);
   
        // if final merged list is empty
        if (head == null)
        { 
            head = top;
                  
            // Points to the last node so far 
            // of the final merged list
            last = top;
        }
        else
        {
            // Insert 'top' at the end of the 
            // merged list so far
            last.next = top;
   
            // Update the 'last' pointer
            last = top;
        }
        pq.sort(function(a,b){return a.data-b.data;});
    }
    // Head node of the required merged list
    return head;
}
  
// Function to print the singly linked list
function printList(head)
{
    while (head != null) 
    {
        document.write(head.data + " ");
        head = head.next;
    }
}
  
// Utility function to create a 
// new node
function push(data)
{
    let newNode = new Node(data);
     newNode.next = null;
     return newNode;
}
  
// Driver code
// Number of linked lists
let k = 3; 
  
// Number of elements in each list
let n = 4; 
  
// An array of pointers storing the 
// head nodes of the linked lists
let arr = new Array(k);
  
arr[0] = new Node(1);
arr[0].next = new Node(3);
arr[0].next.next = new Node(5);
arr[0].next.next.next = new Node(7);
  
arr[1] = new Node(2);
arr[1].next = new Node(4);
arr[1].next.next = new Node(6);
arr[1].next.next.next = new Node(8);
  
arr[2] = new Node(0);
arr[2].next = new Node(9);
arr[2].next.next = new Node(10);
arr[2].next.next.next = new Node(11);
  
// Merge all lists
let head = mergeKSortedLists(arr, k);
printList(head);
  
// This code is contributed by avanitrachhadiya2155

输出：

0 1 2 3 4 5 6 7 8 9 10 11 

复杂性分析：

• 时间复杂度： O(N * log k) or O(n * k * log k)，其中，'N'是所有链表中元素的总数，'k'是链表的总数，' n' 是每个链表的大小。
  所有N个节点的插入和删除操作都会在min-heap中进行。
  最小堆中的插入和删除需要 log k 时间。
• 辅助空间： O(k)。
  优先级队列在任何时间点最多有“k”个元素，因此我们的算法所需的额外空间是 O(k)。

请参阅有关合并 k 排序链表的完整文章 |设置 2（使用最小堆）了解更多详情！