LeetCode 21. Merge Two Sorted Lists

原题链接在这里：https://leetcode.com/problems/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.

题解：

Method 1:

recursion, stop condition: 一条list 空了，返回另外一条。否则比较两个node value, 取小的，对应的点后移，next 指向用作下次比较返回的结果。

Time Complexity: O(m+n), m 是list1的长度，n 是list2 的长度.

Space: recursion 用的stack的大小, O(m+n).

Method 2:

Iteration, 生成一个dummy, 对应生成currentNode 用来iterate. 每次比较两个点，小的连在current 的后面直到 一个为 null, 再把没iterate完的那个连在current后面即可.

Time Complexity: O(m+n).

Space O(1). 

AC Java:

/**
 * 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) {
        /*
        //Method 1, Recursion
        if(l1 == null){
            return l2;
        }
        if(l2 == null){
            return l1;
        }
        
        ListNode mergeHead;
        if(l1.val <= l2.val){
            mergeHead = l1;
            mergeHead.next = mergeTwoLists(l1.next,l2);
        }else{
            mergeHead = l2;
            mergeHead.next = mergeTwoLists(l1,l2.next);
        }
        
        return mergeHead;
        */
        
        //Method 2, Iteration
        if(l1 == null){
            return l2;
        }
        if(l2 == null){
            return l1;
        }
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;
        while(l1!=null && l2!= null){
            if(l1.val<=l2.val){
                current.next = l1;
                l1 = l1.next;
                current = current.next;
            }else{
                current.next = l2;
                l2 = l2.next;
                current = current.next;
            }
        }
        if(l1 != null){
            current.next = l1;
        }
        if(l2 != null){
            current.next = l2;
        }
        return dummy.next;
    }
}

Recursion C++.

AC C++:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == NULL){
            return list2;
        }
        
        if(list2 == NULL){
            return list1;
        }
        
        if(list1 -> val <= list2 -> val){
            list1 -> next = mergeTwoLists(list1 -> next, list2);
            return list1;
        }else{
            list2 -> next = mergeTwoLists(list1, list2 -> next);
            return list2;
        }
    }
};

Iteration C++.

AC C++:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(!list1){
            return list2;
        }
        
        if(!list2){
            return list1;
        }
        
        ListNode* dummy = new ListNode(0);
        ListNode* it = dummy;
        while(list1 && list2){
            if(list1->val <= list2->val){
                it->next = list1;
                list1 = list1->next;
            }else{
                it->next = list2;
                list2 = list2->next;
            }
            
            it = it->next;
        }
        
        if(list1){
            it->next = list1;
        }
        
        if(list2){
            it->next = list2;
        }
        
        return dummy->next;
    }
};

Recursion Python.

AC Python:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        if list1 is None:
            return list2
        
        if list2 is None:
            return list1
        
        if list1.val < list2.val:
            list1.next = self.mergeTwoLists(list1.next, list2)
            return list1
        else:
            list2.next = self.mergeTwoLists(list1, list2.next)
            return list2

Iteration Python.

AC Python:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode(-1)
        it = dummy
        
        while list1 and list2:
            if list1.val <= list2.val:
                it.next = list1
                list1 = list1.next
            else:
                it.next = list2
                list2 = list2.next
            it = it.next
        
        if list1:
            it.next = list1
        if list2:
            it.next = list2
        
        return dummy.next
        

AC JavaScript:

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} l1
 * @param {ListNode} l2
 * @return {ListNode}
 */
var mergeTwoLists = function(l1, l2) {
    var dummy = {
        val : -1,
        next : null
    };
    
    var cur = dummy;
    while(l1 && l2){
        if(l1.val < l2.val){
            cur.next = l1;
            l1 = l1.next;
        }else{
            cur.next = l2;
            l2 = l2.next;
        }
        
        cur = cur.next;
    }
    
    cur.next = l1 || l2;
    return dummy.next;
};

跟上 Merge k Sorted Lists, Merge Sorted Array, Sort List.