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

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;
  }
}

 

 

 

转载于:https://www.cnblogs.com/neweracoding/p/5382275.html