用于合并 K 个已排序链表的 Javascript 程序 – 第 1 组

给定 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.

方法1（简单）：

方法：
一个简单的解决方案是将结果初始化为第一个列表。现在遍历从第二个列表开始的所有列表。将当前遍历列表的每个节点以排序的方式插入到结果中。

Javascript

// Javascript program to merge k sorted
// arrays of size n each
      
// A Linked List node
class Node
{
    // Utility function to create a new node.
    constructor(key)
    {
        this.data = key;
        this.next = null;
    }
}
      
let head;
let temp;
  
/* Function to print nodes in a 
   given linked list */
function printList(node)
{
    while(node != null)
    {
      document.write(node.data + " "); 
      node = node.next;
    }
    document.write("<br>");
          
}
  
// The main function that takes an array 
// of lists arr[0..last] and generates
// the sorted output 
function mergeKLists(arr, last)
{
    // Traverse form second list to last
    for (let i = 1; i <= last; i++)
    {
      while(true)
      {
          // head of both the lists,
          // 0 and ith list. 
          let head_0 = arr[0];
          let head_i = arr[i];
   
          // Break if list ended
          if (head_i == null)
              break;
   
          // Smaller than first element
          if(head_0.data >= head_i.data)
          {
              arr[i] = head_i.next;
              head_i.next = head_0;
              arr[0] = head_i;
          }
          else
          { 
              // Traverse the first list
              while (head_0.next != null)
              { 
                  // Smaller than next element
                  if (head_0.next.data >= head_i.data)
                  {
                      arr[i] = head_i.next;
                      head_i.next = head_0.next;
                      head_0.next = head_i;
                      break;
                  }
   
                  // go to next node
                  head_0 = head_0.next;
   
                  // if last node
                  if (head_0.next == null)
                  {
                      arr[i] = head_i.next;
                      head_i.next = null;
                      head_0.next = head_i;
                      head_0.next.next = null;
                      break;
                  }
              }
          }
       }
    }
    return arr[0];
}
  
// 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
head = mergeKLists(arr, k - 1);
printList(head);
// This code is contributed by unknown2108

输出：

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

复杂性分析：

• 时间复杂度： O(nk ² )
• 辅助空间： O(1)。
  因为不需要额外的空间。

方法2：最小堆。
更好的解决方案是使用基于 Min Heap 的解决方案，这里讨论了数组。该解决方案的时间复杂度为O(nk Log k)方法三：分而治之。
在这篇文章中，讨论了分而治之的方法。这种方法不需要额外的堆空间并且工作在 O(nk Log k)
众所周知，两个链表的合并可以在 O(n) 时间和 O(n) 空间内完成。

1. 这个想法是配对 K 个列表并使用 O(n) 空间在线性时间内合并每一对。
2. 在第一个循环之后，剩下 K/2 个列表，每个列表的大小为 2*N。在第二个循环之后，留下 K/4 个列表，每个列表的大小为 4*N，依此类推。
3. 重复这个过程，直到我们只剩下一个列表。

下面是上述思想的实现。

Javascript

// JavaScript program to merge k sorted
// arrays of size n each
class Node 
{
    constructor(val) 
    {
        this.data = val;
        this.next = null;
    }
}
  
/* Takes two lists sorted in increasing order, 
   and merge their nodes together to make one 
   big sorted list. Below function takes O(Log n) 
   extra space for recursive calls, but it can be 
   easily modified to work with same time and
   O(1) extra space */
function SortedMerge(a, b) 
{
    var result = null;
          
    // Base cases 
    if (a == null)
        return b;
          
     else if (b == null)
         return a;
  
     // Pick either a or b, and recur 
     if (a.data <= b.data) 
     {
         result = a;
         result.next = SortedMerge(a.next, b);
     } 
     else 
     {
         result = b;
         result.next = SortedMerge(a, b.next);
     }
     return result;
}
  
// The main function that takes an array of lists
// arr[0..last] and generates the sorted output
function mergeKLists(arr, last) 
{
    // repeat until only one list is left
    while (last != 0) 
    {
        var i = 0, j = last;
  
        // (i, j) forms a pair
        while (i < j) 
        {
            // merge List i with List j and store
            // merged list in List i
            arr[i] = SortedMerge(arr[i], arr[j]);
  
            // consider next pair
            i++;
            j--;
  
            // If all pairs are merged, update 
            // last
            if (i >= j)
            last = j;
        }
    }
    return arr[0];
}
  
/* Function to print nodes in a given 
   linked list */
function printList(node) 
{
    while (node != null) 
    {
        document.write(node.data + " ");
        node = node.next;
    }
}
  
// Number of linked lists
var k = 3; 
  
// Number of elements in each list
var n = 4; 
  
// An array of pointers storing the 
// head nodes of the linked lists
var arr = 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
var head = mergeKLists(arr, k - 1);
printList(head);
// This code is contributed by gauravrajput1

输出：

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

复杂性分析：

假设 N(n*k) 是节点的总数，n 是每个链表的大小，k 是链表的总数。

• 时间复杂度： O(N*log k) 或 O(n*k*log k)
  作为函数mergeKLists() 中的外部 while 循环运行 log k 次，并且每次它处理 n*k 个元素。
• 辅助空间： O(N) 或 O(n*k)
  因为在 SortedMerge() 中使用了递归并合并最后 2 个大小为 N/2 的链表，所以将进行 N 次递归调用。

请参阅有关 Merge K 排序链表的完整文章 |设置 1 了解更多详情！