21. Merge Two Sorted Lists && 23. Merge k Sorted Lists

最新推荐文章于 2024-01-12 14:30:52 发布

weixin_30929295

最新推荐文章于 2024-01-12 14:30:52 发布

阅读量57

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/neweracoding/p/5382275.html

本文详细介绍了链表合并的两种方法：一种是合并两个已排序的链表，另一种是合并多个已排序的链表。通过递归和分治策略实现高效的合并操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

21. Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Hide Tags

Linked List

Hide Similar Problems

(H) Merge k Sorted Lists (E) Merge Sorted Array (M) Sort List (M) Shortest Word Distance II

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null)
            return l2;
        if(l2 == null)
            return l1;
        ListNode dummy = new ListNode(0);
        ListNode rc = dummy;
        
        while(l1 !=null && l2 !=null)
        {
            if(l1.val<l2.val)
            {
                rc.next = l1;
                l1 = l1.next;
            }
            else
            {
                rc.next = l2;
                l2 = l2.next;
            }
            rc = rc.next;
        }
        
        if(l1 == null)
            rc.next = l2;
        else
            rc.next = l1;
        
        return dummy.next;
    }
}

23. Merge k Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Hide Tags

Divide and Conquer Linked List Heap

Hide Similar Problems

(E) Merge Two Sorted Lists (M) Ugly Number II

Divide and Conquer solution:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
  public ListNode mergeKLists(ListNode[] lists) {
    return mergeKLists(lists, 0, lists.length - 1);
  }

  //[from, to]
  public ListNode mergeKLists(ListNode[] lists, int from, int to) {
    if (from > to)
      return null;
    if (from == to)
      return lists[from];
    if (to - from == 1) {
      ListNode left = lists[from];
      ListNode right = lists[to];
      return merge2Lists(left, right);
    } else {
      int mid = (from + to) / 2;
      ListNode leftMerged = mergeKLists(lists, from, mid);
      ListNode rightMerged = mergeKLists(lists, mid + 1, to);
      return merge2Lists(leftMerged, rightMerged);
    }
  }

  private ListNode merge2Lists(ListNode l1, ListNode l2) {
    if (l1 == null) return l2;
    if (l2 == null) return l1;

    ListNode fake = new ListNode(0);
    ListNode current = fake;
    while (l1 != null && l2 != null) {
      if (l1.val <= l2.val) {
        current.next = l1;
        l1 = l1.next;
      } else {
        current.next = l2;
        l2 = l2.next;
      }
      current = current.next;
    }

    if (l1 != null) current.next = l1;
    if (l2 != null) current.next = l2;

    return fake.next;
  }
}