LeetCode 21.Merge Two Sorted Lists Easy/Linked List

---

1.Description

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

---

2.Example

Input: l1 = [1,2,4], l2 = [1,3,4]
Output: [1,1,2,3,4,4]

---

3.Solution

1.迭代：创建新链表一个一个添加

首先创建两个新的，一个用于添加一个用于保存首地址；然后判断是否有空参数的情况；之后就是按元素的大小一个一个添加，当一个链表添加完之后将剩余的链表全部添加进去。
时间复杂度：O（n+m）
空间复杂度：O（1）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next;
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode l3 = new ListNode();
        ListNode l4;
        if(l1==null&&l2==null) return null;//判断是否为空
        if(l1==null){
            return l2;
        }else if(l2==null){
            return l1;
        }
        if(l1.val<=l2.val){//给出头结点的地址
            l3 = l1;
            l4 = l3;
            l1 = l1.next;
        }else{
            l3 = l2;
            l4 = l3;
            l2 = l2.next;
        }
        while(l1!=null&&l2!=null){//按大小一个一个添加
            if(l1.val<=l2.val){
                l3.next = l1;
                i3 = i3.next；
                l1 = l1.next;
            }else{
                l3.next = l2;
                i3 = i3.next；
                l2 = l2.next;
            }
        }
        if(l1==null){//一个链表添加完后剩余的全部添加
                l3.next = l2;
        }else{
                l3.next = l1;
       }
        return l4;
    }
}

答案中合并了判断空参数的情况，更简洁。
答案：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);
        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }
        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;
        return prehead.next;
    }
}

2.递归

答案：
注意这里递归调用的空间复杂度取决于递归调用的深度，这里最深是两个链表的长度相加：n+m，因此空间复杂度是O（n+m）。
时间复杂度：O（n+m）。

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