LeetCode——21. 合并两个有序链表

题目描述：【腾讯精选练习（50 题）】

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

ListNode类： 

    /**
     * 因为每一个节点都是ListNode的一个对象，所以next即下一个节点也是ListNode类型
     */
    class ListNode { //类
        int val; //内部实例变量
        ListNode next; //下一个节点 //指向下一个要链接的本类型的结构变量

        ListNode(int x) { //构造函数的初始化 //构造函数就是初始化实例变量，类似int val 的地方
            val = x;
            //next = null;
        }
    }

解题代码：

    /**
     * 解法一：迭代
     * 思路
     * 因为两个链表都是有序链表（递增），因此可以很容易地找出两个链表中的最小元素，即比较两个链表表头的元素，时间复杂度是O(1)。
     * 我们可以利用两个指针——指向两个链表的最小节点，每次比较两个指针所指向节点的值，将值比较小的节点加到新的链表中，然后更新指针，如此循环往复直到到达一个链表的尾部。
     * 最后，还需要将另一个链表的剩余部分（如果存在的话）添加到新的链表的尾部。
     */
    class Solution {
        public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
            ListNode dummyHead = new ListNode(0);
            ListNode lastNode = dummyHead;
            while (l1 != null && l2 != null) {
                if (l1.val < l2.val) {
                    lastNode.next = l1;
                    l1 = l1.next;
                } else {
                    lastNode.next = l2;
                    l2 = l2.next;
                }
                lastNode = lastNode.next;
            }
            lastNode.next = l1 != null ? l1 : l2;
            return dummyHead.next;
        }
    }

复杂度分析

• 时间复杂度：O(m+n)，其中，m 为链表 1 的节点数，n 为链表 2 的节点数，算法需要遍历两个链表的所有元素。
• 空间复杂度：O(1)，只需要保存两个引用。

    /**
     * 解法二：递归
     * 思路
     * 递归的思路和迭代的思路是相同的，都是每次比较两个链表的最小节点，然后对值更小的节点进行操作。
     * 不同的是，迭代是从值比较小的节点开始组建新的链表，而递归则是从值比较大的节点开始组建新的链表——递归到其中一个链表的尾部才开始组建新的链表。
     */
    class Solution {
        public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
            if (l1 == null || l2 == null) {
                return l1 != null ? l1 : l2;
            }
            if (l1.val < l2.val) {
                l1.next = mergeTwoLists(l1.next, l2);
                return l1;
            } else {
                l2.next = mergeTwoLists(l1, l2.next);
                return l2;
            }
        }
    }

复杂度分析

• 时间复杂度：O(m+n)，其中，m 为链表 1 的节点数，n 为链表 2 的节点数，算法需要遍历两个链表的所有元素。

• 空间复杂度：O(m+n)，额外的空间是由于递归调用占用系统栈的空间，递归的深度最多为 m+n 层。