【LeetCode】详解合并两个有序链表21. Merge Two Sorted Lists Merge two sorted linked lists and return it as a new

---

前言

今天带来的是一道跟链表有关系的题，还是跟之前的博文一样，先提供比较笨的思路，再提供比较优的思路，希望能给大家带来帮助。

---

正文

原题：

链接：合并两个有序链表

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.
Example:
Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4

题目大意
给定两个有序的链表，返回一个有序的新链表，新链表由两个有序链表的节点组成。

思路1：

一开始我用的是比较慢也比较笨的方法，使用list存储每个链表的元素，并将list排序，将排序后的list中的元素依次添加到新的链表中。

代码

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if (l1 == null && l2 == null) {
        return null;
    }
    LinkedList<Integer> list = new LinkedList<>();
    // 往list中添加l1的元素
    while (l1 != null) {
        list.add(l1.val);
        l1 = l1.next;
    }
    // 往list中添加l2的元素
    while (l2 != null) {
        list.add(l2.val);
        l2 = l2.next;
    }
    // 将list转为整型数组
    Integer[] nums = (Integer[]) list.toArray(new Integer[list.size()]);
    ListNode tempNode = new ListNode(0);
    ListNode result = tempNode;
    // 对数组排序
    Arrays.sort(nums);
    for (int i = 0; i < nums.length; i++) {
        // 将排序后的list的元素依次添加到链表中
        tempNode.val = nums[i];
        // 若不是最后一个元素，则持续创建节点（即最后一个元素，不再创建节点）
        if (i < nums.length - 1) {
            tempNode.next = new ListNode(0);
            tempNode = tempNode.next;
        }
    }
    return result;
}

代码讲解
这里我使用了LinkedList，因为LinkedList底层是由链表组成，在进行频繁插入数据时性能会比较快。
往list添加了l1和l2链表的元素之后，将其转换为Integer数组，这是为了方便排序

// 将list转为整型数组
Integer[] nums = (Integer[]) list.toArray(new Integer[list.size()]);

最后把排序后的数组添加到新链表即可，提交代码，时间有点慢

思路2：

换一种思路，如果不使用list的方式需要怎么做？
我们可以直接比较两个链表的元素大小，然后依次地将元素填入新链表中，怎么填入新链表中呢？这里使用谁小填谁，谁小移谁的方法，看图解释吧

如果两个元素相等，则默认填链表1的元素，此时新链表添加元素为1的节点，l1往右移，指向元素2，如下图所示：

由于l2中的元素1小于l1中的元素2，将1填入新链表，并右移l2，如下图所示：

重复以上判断，直到其中一个链表遍历结束，如下图所示：


如上图所示，此时链表1遍历结束，再将链表2单独添加到新链表中，元素添加完毕

代码

public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if (l1 == null && l2 == null) {
        return null;
    }
    // 新链表，用于添加新元素
    ListNode temp = new ListNode(0);
    // 用于返回结果
    ListNode merge = temp;
    // 将l1链表以及l2链表按照谁小谁填、谁小谁移的原则添加到新链表中
    while (l1 != null && l2 != null) {
        if (l1.val <= l2.val) {
            temp.val = l1.val;
            l1 = l1.next;
        } else {
            temp.val = l2.val;
            l2 = l2.next;
        }
        temp.next = new ListNode(0);
        temp = temp.next;
    }
    //下面两个while有且仅有一个会执行
    //将剩下的链表添加到新链表中
    while (l1 != null) {
        temp.val = l1.val;
        l1 = l1.next;
        if (l1 != null) {
            temp.next = new ListNode(0);
            temp = temp.next;
        }
    }
    while (l2 != null) {
        temp.val = l2.val;
        l2 = l2.next;
        if (l2 != null) {
            temp.next = new ListNode(0);
            temp = temp.next;
        }
    }
    return merge;
}

代码讲解
下面这段代码比较好理解，作用就是将l1链表以及l2链表按照谁小谁填、谁小谁移的原则添加到新链表中

while (l1 != null && l2 != null) {
    if (l1.val <= l2.val) {
        temp.val = l1.val;
        l1 = l1.next;
    } else {
        temp.val = l2.val;
        l2 = l2.next;
    }
    temp.next = new ListNode(0);
    temp = temp.next;
}

下面的代码，有且仅有一个while会执行，而且是必然执行的，这是由于在比较两个链表的时候，总会有一个先添加完，另外一个还没添加到新链表中，如上述例子的l2链表就有剩余一个元素4，这时候单独遍历链表，并添加到新链表中

while (l1 != null) {
    temp.val = l1.val;
    l1 = l1.next;
    if (l1 != null) {
        temp.next = new ListNode(0);
        temp = temp.next;
    }
}
while (l2 != null) {
    temp.val = l2.val;
    l2 = l2.next;
    if (l2 != null) {
        temp.next = new ListNode(0);
        temp = temp.next;
    }
}

单独遍历链表2，将其添加到新链表中

提交代码，时间快了不少（虽说仅有2ms）！

---

总结

使用辅助list存储链表的方式看起来可能比较笨，但是在提交代码过程中，好像总比使用多个链表方式的内存占用少，只是list辅助消耗时间比后者长。
因此在很多题中，存在不少用空间换时间的解题步骤，具体使用哪种就看读者了，今天的题目就到这里！