Java实现 亚博体育LeetCode 23 合并K个排序链表

  • 合并K个排序链表
  • 合并 k 个排序链表,返回合并后的排序链表。请分析和描述算法的复杂度。

    示例:

    输入:
    [
    1->4->5,
    1->3->4,
    2->6
    ]
    输出: 1->1->2->3->4->4->5->6

    PS:直接用PriorityQueue自动排序,改写一下compare方法。

    /**

    • Definition for singly-linked list.
    • public class ListNode {
    • int val;
    • ListNode next;
    • ListNode(int x) { val = x; }
    • }
      */
      class Solution {
      public ListNode mergeKLists(ListNode[] lists) {
      if (lists.length == 0) {
          return null;
      }
      
      ListNode dummyHead = new ListNode(0);
      ListNode curr = dummyHead;
      PriorityQueue<ListNode> pq = new PriorityQueue<>(new Comparator<ListNode>() {
          @Override
          public int compare(ListNode o1, ListNode o2) {
              return o1.val - o2.val;
          }
      });
      
      for (ListNode list : lists) {
          if (list == null) {
              continue;
          }
          pq.add(list);
      }
      
      while (!pq.isEmpty()) {
          ListNode nextNode = pq.poll();
          curr.next = nextNode;
          curr = curr.next;
          if (nextNode.next != null) {
              pq.add(nextNode.next);
          }
      }
      return dummyHead.next;

      }
      }

    PS:分治

    /**

    • Definition for singly-linked list.
    • public class ListNode {
    • int val;
    • ListNode next;
    • ListNode(int x) { val = x; }
    • }
      */
      class Solution {
      public ListNode mergeKLists(ListNode[] lists){
      if(lists.length == 0)
      return null;
      if(lists.length == 1)
      return lists[0];
      if(lists.length == 2){
      return mergeTwoLists(lists[0],lists[1]);
      }
      int mid = lists.length/2;
      ListNode[] l1 = new ListNode[mid];
      for(int i = 0; i < mid; i++){
          l1[i] = lists[i];
      }
      
      ListNode[] l2 = new ListNode[lists.length-mid];
      for(int i = mid,j=0; i < lists.length; i++,j++){
          l2[j] = lists[i];
      }
      
      return mergeTwoLists(mergeKLists(l1),mergeKLists(l2));

      }
      public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
      if (l1 == null) return l2;
      if (l2 == null) return l1;

      ListNode head = null;
      if (l1.val <= l2.val){
          head = l1;
          head.next = mergeTwoLists(l1.next, l2);
      } else {
          head = l2;
          head.next = mergeTwoLists(l1, l2.next);
      }
      return head;

      }
      }
      4

    原文地址:https://blog.51cto.com/14073038/2471173

    时间: 2024-11-07 14:28:22

    Java实现 亚博体育LeetCode 23 合并K个排序链表的相关文章

    LeetCode 23. 合并K个排序链表(Merge Two Sorted Lists)

    23. 合并K个排序链表 23. Merge k Sorted Lists 题目描述 合并 k 个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度. LeetCode23. Merge k Sorted Lists困难 示例: 输入: [ ??1->4->5, ??1->3->4, ??2->6] 输出: 1->1->2->3->4->4->5->6 Java 实现 public class ListNode { int va

    [leetcode] 23. 合并K个排序链表

    23. 合并K个排序链表 这个题算是考察代码功底吧,基本功,对变量与引用的理解. 不多说了,思路跟第21题基本一致,只不过从两个换成了多个 class Solution { public ListNode mergeKLists(ListNode[] lists) { List<ListNode> listNodes = new ArrayList<>(Arrays.asList(lists)); ListNode ans = new ListNode(Integer.MAX_VA

    [LeetCode]23. 合并K个排序链表(优先队列;分治待做)

    题目 合并?k?个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度. 示例: 输入: [ ? 1->4->5, ? 1->3->4, ? 2->6] 输出: 1->1->2->3->4->4->5->6 来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/merge-k-sorted-lists 著作权归领扣网络所有.商业转载请联系官方授权,非商业转载请注明出处. 题解 方法

    23. 合并K个排序链表

    知乎ID: 码蹄疾 码蹄疾,毕业于哈尔滨工业大学. 小米广告第三代广告引擎的设计者.开发者: 负责小米应用商店.日历.开屏广告业务线研发:主导小米广告引擎多个模块重构: 关注推荐.搜索.广告领域相关知识; 题目 合并 k 个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度.示例:输入:[ 1->4->5, 1->3->4, 2->6]输出: 1->1->2->3->4->4->5->6 分析 前面已经做过两个有序链表的合并,只

    leetcode(14)-合并k个排序链表

    合并?k?个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度. 示例: #输入: [ ? 1->4->5, ? 1->3->4, ? 2->6 ] #输出: 1->1->2->3->4->4->5->6 链接:https://leetcode-cn.com/problems/merge-k-sorted-lists 自己的思路 在k个链表中找到一个比较节点,然后把k个链表分成两部分,一部分都比比较节点小,一部分都比比较节点大,

    leetcode 23 合并 k 个有序链表

    问题描述 * leetcode 23,  Merge k Sorted Lists 解题思路 合并2个有序链表的进阶版,很容易想到,利用分治进行处理. 把个数大于2的集合 两两划分处理,最后再做最后一步的处理. 1 public class Solution { 2 public ListNode mergeKLists(ListNode[] lists) { 3 if (lists.length==0 || lists==null) { return null; } 4 return merg

    23. 合并K个排序链表-LeetCode

    心得:仿照归并排序,两两合并,注意更新的判断条件,注意事项看代码!!! 注意判断条件. ** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode mergeKLists(ListNode[] lists) { if(lists=

    23. 合并K个排序链表 分治

    这种k个相同的子问题,可以两两分治,总的运算次数为logk 关键部分 int dis=1; int len=lists.size(); while(dis<=len) { for(int i=0;i<len-dis;i=i+dis*2){ lists[i]=solve(lists[i],lists[i+dis]); } dis*=2; } return lists[0]; (每次运算后剩下的子问题个数为 x/2 向上取整,这样每次/2,最后问题一定会解决) 注意判断空数组 /** * Defi

    LeetCode 第23题 合并K个排序链表

    /* 23. 合并K个排序链表 合并 k 个排序链表,返回合并后的排序链表.请分析和描述算法的复杂度. 示例: 输入:[ 1->4->5, 1->3->4, 2->6]输出: 1->1->2->3->4->4->5->6 */ /** * Definition for singly-linked list. public class ListNode { int val; ListNode next; ListNode(int * x