LeetCode-21-合并两个有序链表

LeetCode-21-合并两个有序链表

---

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

---

示例：

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

---

解题思路：

Alice: 合并两个有序链表？[・_・?]
Bob：就是修改这些 节点的指向关系，然后把它们变成一个有序的就可以了，就直接根据题意的逻辑就好了。
Alice : 那这种题目应该是模拟题了 ?
Bob：对啊。
Alice: 那这道题究竟在考什么呢？
Bob: 考对链表这种数据结构的使用？如果是培训班选手的话，做这种题目还是会有些不熟练的。
Alice: ヽ(ー_ー)ノ，合并两个有序链表，就像是双指针， 不断比较两个链表中当前的那对元素的大小，小的先加进来，大的需要等到下一轮继续比较。一直到两个链表中的所有元素都加进去了，或者其中一个链表的元素都加进去了，就把另一个链表剩下的元素也都一起加进去就好了。
Bob: 没错，Bravo. 我还有一个奇怪的方法， 把所有的节点都放到一个列表里面，然后根据节点的值对节点排序，然后直接建立指向关系。这样写多简单啊！
Alice: 需要排序呀，那你的时间复杂度最少也是O(n*logn) + O(n) 了，直接合并就是O(n)。题目要是严一点你就过不去了。
Bob: 是啊，还是正常一点好，捷径不好走的。

---

代码：

Python 方法一：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        if l1 == None and l2 == None:
            return None
        res = self.getNodes(l1)
        res += self.getNodes(l2)  // 将所有节点取出并按照值排序
        res.sort(key = lambda node: node.val) 
        for x in range(len(res)-1): // 建立新链表的连接关系，注意有一个小小的不确定性，当输入是1->2->4->4, 1->3->4的时候有可能是第一个链表倒数第二的那个4被排到了末尾。。。
            res[x].next = res[x+1]
        return res[0]      
    
    def getNodes(self, l):
        res = []
        while l != None:
            res.append(l)
            l = l.next
        return res
            

Python 方法二：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def mergeTwoLists(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        if l1 == None and l2 == None:
            return None
        if l1 == None and l2 != None:
            return l2
        if l1 != None and l2 == None:
            return l1
        if l1 != None and l2 != None:
            if l1.val < l2.val:
                head = l1
                l1 = l1.next
            else:
                head = l2
                l2 = l2.next
            tmp = head
            while l1 != None or l2 != None:
                if l1 == None:
                    tmp.next = l2
                    break
                if l2 == None:
                    tmp.next = l1
                    break
                if l1.val < l2.val:
                    tmp.next = l1
                    l1 = l1.next
                else:
                    tmp.next = l2
                    l2 = l2.next
                tmp = tmp.next
            return head
       

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) {
        if(l1 == null && l2 == null){
            return null;
        }else if(l1 == null && l2 != null){
            return l2;
        }else if(l1 != null && l2 == null){
            return l1;
        }else{
            ListNode head = new ListNode(0);
            if(l1.val < l2.val){
                head.val = l1.val;
                l1 = l1.next;
            }else{
                head.val = l2.val;
                l2 = l2.next;
            }
            ListNode tmp =  head;
            while(l1 != null || l2 != null){
                if(l1 == null){
                    tmp.next = l2;
                    break;
                }
                if(l2 == null){
                    tmp.next = l1;
                    break;
                }
                if(l1.val < l2.val){
                    tmp.next = l1;
                    l1 = l1.next;
                }else{
                    tmp.next = l2;
                    l2 = l2.next;
                }
                tmp = tmp.next;
            }
            return head;
        }
    }
}

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 == NULL && l2 == NULL){
            return NULL;
        }else if(l1 == NULL && l2 != NULL){
            return l2;
        }else if(l1 != NULL && l2 == NULL){
            return l1;
        }else{
            ListNode* head = new ListNode(0);
            ListNode* tmp = head;
            while(l1 != NULL || l2 != NULL){
                if(l1 == NULL){
                    tmp->next = l2;
                    break;
                }
                if(l2 == NULL){
                    tmp->next = l1;
                    break;
                }
                if(l1->val < l2->val){
                    tmp->next = l1;
                    l1 = l1->next;
                }else{
                    tmp->next = l2;
                    l2 = l2->next;
                }
                tmp = tmp->next;
            }
            return head->next;
        }
        return l1;
    }
};

---

易错点：

• 注意一下合并后的链表的头和尾 ？？

---

总结：

• 链表是常用的基础数据结构，尽早掌握。

---