Java程序合并 K 个已排序的链表 – 第 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（简单）：

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

Java

// Java program to merge k sorted
// linked lists of size n each
import java.io.*;
  
// A Linked List node
class Node
{
  int data;
  Node next;
  
  // Utility function to create 
  // a new node.
  Node(int key)
  {
    data = key;
    next = null;
  }
}
class GFG 
{
  static Node head;
  static Node temp;
  
  /* Function to print nodes in 
     a given linked list */
  static void printList(Node node)
  {
    while(node != null)
    {
      System.out.print(node.data + " ");
  
      node = node.next;
    }
    System.out.println();
  }
  
  // The main function that takes an array 
  // of lists arr[0..last] and generates
  // the sorted output 
  static Node mergeKLists(Node arr[], 
                          int last)
  {
    // Traverse form second list to last
    for (int i = 1; i <= last; i++)
    {
      while(true)
      {
        // head of both the lists,
        // 0 and ith list.  
        Node head_0 = arr[0];
        Node 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  
  public static void main (String[] args) 
  {
    // Number of linked lists
    int k = 3;
  
    // Number of elements in each list
    int n = 4;
  
    // an array of pointers storing the
    // head nodes of the linked lists
  
    Node[] arr = new Node[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 avanitrachhadiya2155

输出：

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. 重复这个过程，直到我们只剩下一个列表。

下面是上述思想的实现。

Java

// Java program to merge k sorted 
// linked lists of size n each
public class MergeKSortedLists 
{
    /* 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  */
    public static Node SortedMerge(Node a, Node b)
    {
        Node 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
    public static Node mergeKLists(Node arr[], 
                                   int last)
    {
        // Repeat until only one list is left
        while (last != 0) 
        {
            int 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 */
    public static void printList(Node node)
    {
        while (node != null)
        {
            System.out.print(node.data + " ");
            node = node.next;
        }
    }
  
    public static void main(String args[])
    {
        // Number of linked lists
        int k = 3; 
  
        // Number of elements in each list
        int n = 4; 
  
        // An array of pointers storing the 
        // head nodes of the linked lists
        Node arr[] = new Node[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
        Node head = mergeKLists(arr, k - 1);
        printList(head);
    }
}
  
class Node 
{
    int data;
    Node next;
    Node(int data)
    {
        this.data = data;
    }
}
// This code is contributed by Gaurav Tiwari

输出：

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 了解更多详情！