【LeetCode热题100】3.合并两个有序链表

合并两个有序链表

题号：21
难度：简单
标签：链表

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

示例：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-sorted-lists
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

（1）自己的解法（Java）

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        // node用来构建合并的链表，先新建一个值为-1的节点，从下一节点开始才是合并链表的头节点
        ListNode node = new ListNode(-1);
        // res用来获取链表的头，node会不断后移，因此需要有res指向node的头
        ListNode res = node;
        while(l1 != null && l2 != null) {
            // 主循环，每次循环执行条件语句，当前两个节点中值较小的连接到node的下一节点
            // 然后该节点和node节点均移动到下一节点，直到l1或l2中任意一个所有节点已连接到node上，后移后成为空节点，此时结束循环
            if (l1.val > l2.val) {
                node.next = l2;
                l2 = l2.next;
            }
            else {
                node.next = l1;
                l1 = l1.next;
            }
            node = node.next;
        }

        // 结束循环后，其中一个节点为空，另一节点至少还有一个元素，因此通过判断，将非空的节点接到node的下一节点
        // 因为另一节点已空，所以可以把之后的所有节点直接接上
        node.next = l1 != null ? l1 : l2;

        // res指向的是合并链表第一个节点的前一节点，所以需要返回res的下一节点
        return res.next;
    }
}

思路：
        建立两个节点对象，一个用来指向链表头结点，作为结果返回，另一个用于构建合并的链表。
        进行一层while循环，循环结束条件是l1和l2其中一个节点为null，循环中进行判断，将l1和l2中当前节点中较小的节点连接到node上，并将此节点和node节点后移，然后进行下次循环，直到l1和l2其中一个节点所在链表的所有有值节点均已连接到node节点的链表上，此时该节点是空节点，直接触发循环结束条件退出循环。
        因为每次循环只后移l1和l2节点中的一个，所以退出循环后俩节点中一个节点是非空的，甚至可能还形成一条很长的链表，因为是有序的，只需要将其接到node的下一节点就行了，因此进行条件语句判断，将非空节点接到node的下一节点。
        最后，node节点指向的已经不是合并链表的第一个节点，不能作为结果返回，但开始时还创建了一个节点对象res指向合并链表第一个节点的前一节点，所以返回res的下一节点即可。

结果：

通过
执行用时 :0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗 :39.4 MB, 在所有 Java 提交中击败了57.94%的用户

（2）官方提交的较优解法，递归法（Java）

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

思路：
        第一次执行时，l1和l2均非空，则会进入第三或第四个分支，否则直接返回另一节点，第三或第四个分支会调用方法mergeTwoLists进行递归，参数是当前节点的下一节点和另一节点，返回结果会赋值给当前节点的下一节点，而递归结束的条件是l1或l2等于null，此时会返回另一节点，因此递归时，会不断按顺序后移l1和l2，直到其中一个为null，这时将另一节点接到该节点，然后退出当前递归层，退出的过程是不断从链表结尾往前返回一个顺序链表，返回的链表会原来越长（头结点越来越浅），最后获得完整合并链表头结点并返回。

结果：

通过
执行用时 :0 ms, 在所有 Java 提交中击败了100.00%的用户
内存消耗 :39.6 MB, 在所有 Java 提交中击败了51.40%的用户

（3）解法一的C++实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* node = new ListNode(-1);

        ListNode* res = node;

        while (l1 != nullptr && l2 != nullptr) {
            if (l1->val < l2->val) {
                node->next = l1;
                l1 = l1->next;
            }
            else {
                node->next = l2;
                l2 = l2->next;
            }
            node = node->next;
        }

        node->next = l1 != nullptr ? l1 : l2;
        return res->next;
    }
};

结果：

通过
执行用时 :8 ms, 在所有 C++ 提交中击败了85.59%的用户
内存消耗 :7.1 MB, 在所有 C++ 提交中击败了100.00%的用户

（4）解法二的C++实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == nullptr) {
            return l2;
        }
        else if (l2 == nullptr) {
            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;
        }
    }
};

结果：

通过
执行用时 :12 ms, 在所有 C++ 提交中击败了50.89%的用户
内存消耗 :7.1 MB, 在所有 C++ 提交中击败了100.00%的用户