【LeetCode热题100】打卡第13天：合并 K 个升序链表

合并 K 个升序链表

⛅前言

大家好，我是知识汲取者，欢迎来到我的LeetCode热题100刷题专栏！

精选 100 道力扣（LeetCode）上最热门的题目，适合初识算法与数据结构的新手和想要在短时间内高效提升的人，熟练掌握这 100 道题，你就已经具备了在代码世界通行的基本能力。在此专栏中，我们将会涵盖各种类型的算法题目，包括但不限于数组、链表、树、字典树、图、排序、搜索、动态规划等等，并会提供详细的解题思路以及Java代码实现。如果你也想刷题，不断提升自己，就请加入我们吧！QQ群号：827302436。我们共同监督打卡，一起学习，一起进步。

博客主页：知识汲取者的博客

LeetCode热题100专栏：LeetCode热题100

Gitee地址：知识汲取者 (aghp) - Gitee.com

Github地址：Chinafrfq · GitHub

题目来源：LeetCode 热题 100 - 学习计划 - 力扣（LeetCode）全球极客挚爱的技术成长平台

PS：作者水平有限，如有错误或描述不当的地方，恳请及时告诉作者，作者将不胜感激

题目

原题链接：23. 合并 K 个升序链表 - 力扣（LeetCode）

题解

• 解法一：暴力

  这个没有任何逻辑可言，纯纯靠调用API，所以耗时较高，但是时间复杂度不是很高。相较而言，我感觉这个代码思路还是十分清晰易懂的，毕竟是自己写的

  PS：从LeetCode热题100系列开始，截至目前为止，我已经遇到了三道困难题，从这三道题来看，发现困难题都有“取巧”的方法，但是一般“取巧”做出来的代码耗时或耗内存都比较高

  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  
  class ListNode {
      int val;
      ListNode next;
  
      ListNode() {
      }
  
      ListNode(int val) {
          this.val = val;
      }
  
      ListNode(int val, ListNode next) {
          this.val = val;
          this.next = next;
      }
  }
  
  /**
   * @author ghp
   * @title 括号生成
   */
  class Solution {
      public ListNode mergeKLists(ListNode[] lists) {
          // 判空
          if (lists.length == 0){
              return null;
          }
          int count = 0;
          for (int i = 0; i < lists.length; i++) {
              if (lists[i] == null){
                  count++;
              }
          }
          if (count == lists.length){
              // lists不为空，但是lists中的链表都为空
              return null;
          }
          // 将 lists 中所有的元素都转存到 list 集合中
          List<Integer> list = new ArrayList<>(10);
          for (int i = 0; i < lists.length; i++) {
              ListNode tempNode = lists[i];
              while (tempNode != null){
                  list.add(tempNode.val);
                  tempNode = tempNode.next;
              }
          }
          // 对 list 进行排序（升序，值由低到高）
          Collections.sort(list);
          // 将 list 中所有的元素都转存到链表中
          ListNode newNode = new ListNode(list.get(0));
          ListNode t = newNode;
          for (int i = 1; i < list.size(); i++) {
              ListNode tempNode = new ListNode(list.get(i));
              t.next = tempNode;
              t = t.next;
          }
          return newNode;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(n\ast k)$
  • 空间复杂度：$O(1)$

  其中 $n$ 为最长链表的长度，k为链表数组的长度

• 解法二：按顺序合并两个链表

  这个解法是LeetCode官方提供的一种解法，时间复杂度比我提供的那种要高，耗时也高，唯一比解法一要好的就是内存占用少。解题思路也比较简单，使用一个链表来存储合并后的链表，然后两两合并

  class Solution {
      public ListNode mergeKLists(ListNode[] lists) {
          ListNode ans = null;
          // 遍历所有链表，两两合并
          for (int i = 0; i < lists.length; i++) {
              // 合并两个链表
              ans = merge(ans, lists[i]);
          }
          return ans;
      }
  
      private ListNode merge(ListNode node1, ListNode node2) {
          // 尽量返回非空链表
          if (node1 == null || node2 == null) {
              return node1 == null ? node2 : node1;
          }
          // 合并两个链表
          ListNode i = node1;
          ListNode j = node2;
          ListNode head = new ListNode();
          ListNode k = head;
          while (i != null && j != null) {
              if (i.val <= j.val) {
                  // node1的节点值较小，则将node1的节点添加到head链表后
                  k.next = i;
                  i = i.next;
              } else {
                  // node2的节点值较小，则将node2的节点添加到head链表后
                  k.next = j;
                  j = j.next;
              }
              k = k.next;
          }
          // 将还剩有节点的拼接到 head 末尾
          k.next = i != null ? i : j;
          // 返回构建好的链表，注意不要将头节点返回
          return head.next;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(k^{2}n)$
  • 空间复杂度：$O(1)$

  其中 $n$ 为最长链表的长度，k为链表数组的长度

• 解法三：分治+递归

  说实话，我最先想到的其实是这种解法，但是最后没有写出来，最后才想出了解法一o((>ω< ))o（我还有待加强），这种方法思路也是挺简单的，相信只要学习过归并排序，都会想到这种思想。这种方法效率是三种解法中最高的

  

  class ListNode {
      int val;
      ListNode next;
  
      ListNode() {
      }
  
      ListNode(int val) {
          this.val = val;
      }
  
      ListNode(int val, ListNode next) {
          this.val = val;
          this.next = next;
      }
  }
  
  /**
   * @author ghp
   * @title 括号生成
   */
  class Solution {
      public ListNode mergeKLists(ListNode[] lists) {
          // 划分数组
          return partition(lists, 0, lists.length-1);
      }
  
      /**
       * 划分数组
       *
       * @param lists
       * @param l     左侧子数组的起始索引
       * @param r     右侧子数组的起始索引
       * @return
       */
      private ListNode partition(ListNode[] lists, int l, int r) {
          // 递归终止条件
          if (l > r) {
              return null;
          }
          if (l == r) {
              return lists[l];
          }
          int mid = (r - l) / 2 + l;
          // 划分左侧子数组
          ListNode node1 = partition(lists, l, mid);
          // 划分右侧子数组
          ListNode node2 = partition(lists, mid + 1, r);
          // 合并子数组
          return merge(node1, node2);
      }
  
      private ListNode merge(ListNode node1, ListNode node2) {
          // 尽量返回非空链表
          if (node1 == null || node2 == null) {
              return node1 == null ? node2 : node1;
          }
          // 合并两个链表
          ListNode i = node1;
          ListNode j = node2;
          ListNode head = new ListNode();
          ListNode k = head;
          while (i != null && j != null) {
              if (i.val <= j.val) {
                  // node1的节点值较小，则将node1的节点添加到head链表后
                  k.next = i;
                  i = i.next;
              } else {
                  // node2的节点值较小，则将node2的节点添加到head链表后
                  k.next = j;
                  j = j.next;
              }
              k = k.next;
          }
          // 将还剩有节点的拼接到 head 末尾
          k.next = i != null ? i : j;
          // 返回构建好的链表，注意不要将头节点返回
          return head.next;
      }
  }
  

  复杂度分析：

  • 时间复杂度：$O(kn\ast logk)$
  • 空间复杂度：$O(logk)$

  其中 $n$ 为最长链表的长度，k为链表数组的长度