LeetCode第 21 题：合并两个有序链表(C++)

leetcode链接

第一种方法（借助其他标准库容器）

遍历两个链表将元素均存入容器中（例如vector,或者multiset会更好吗？），调用泛型算法sort进行元素排序，最后在新建链表将排序好的元素导过去：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        vector<int> vec;
        while(l1 != NULL){
            vec.push_back(l1->val);
            l1 = l1->next;
        }
        while(l2 != NULL){
            vec.push_back(l2->val);
            l2 = l2->next;
        }

        sort(vec.begin(), vec.end());
        auto head = new ListNode;
        auto cur = head;
        for(const auto &c : vec){
            auto p = new ListNode(c);
            cur->next = p;
            cur = p;
        }
        return head->next;
    }
};

实测 $\uparrow$ 性能不行，使用multiset也不太行的样子。。。

迭代

遍历的时候一边比较一边插入
简单易懂：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        // 不用判断是否有空链表
        auto head = new ListNode;
        auto cur = head;
        while(l1 != NULL && l2 != NULL){
            if(l1->val <= l2->val){
                auto p  = new ListNode(l1->val);
                cur->next = p;
                cur = p;
                l1 = l1->next;
            }else{
                auto p  = new ListNode(l2->val);
                cur->next = p;
                cur = p;
                l2 = l2->next;
            }
        }
    
        auto lst = (l1 == NULL) ? l2 : l1;
        while(lst != NULL){
            auto p  = new ListNode(lst->val);
            cur->next = p;
            cur = p;
            lst = lst->next;
        }

        return head->next;
    }
};

第一遍写完之后发现上述代码很繁琐，优化如下：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        auto head = new ListNode;
        auto cur = head;
        while(l1 != NULL && l2 != NULL){
            if(l1->val <= l2->val){
                cur->next = l1;
                l1 = l1->next;
            }else{
                cur->next = l2;
                l2 = l2->next;
            }
            cur = cur->next;
        }
        
        cur->next = (l1 == NULL) ? l2 : l1;

        return head->next;
    }
};

还能写成这样：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        auto head = new ListNode;
        auto cur = head;
        while(l1 != NULL && l2 != NULL){
            // p是指向链表的指针
            auto p = (l1->val < l2->val) ? &l1 : &l2;
            cur->next = *p;
            cur = cur->next;
            *p = (*p)->next; 
        }
        
        cur->next = (l1 == NULL) ? l2 : l1;
        auto ans = head->next;
        delete head;
        return ans;
    }
};

递归

写过206题的递归之后，这题的递归更简单，但是性能有待优化，不如上一种：
先判断是否有空链表，有则返回另一个链表；
比较两链表的头结点，偏小值做新链表的第一个结点，且该节点的next指向本函数（参数为较小值所在链表->next和另一个链表）。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
        auto head = new ListNode;
        auto cur = head;
        if(l1->val <= l2->val){
            auto p = new ListNode(l1->val);
            cur->next = p;
            cur = p;
            cur->next =  mergeTwoLists(l1->next, l2);
        }else{
            auto p = new ListNode(l2->val);
            cur->next = p;
            cur = p;
            cur->next = mergeTwoLists(l2->next, l1);
        }

        return head->next;
    }
};

优化(之前创建新的 p 好像是不必要的)：

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if(l1 == NULL)
            return l2;
        if(l2 == NULL)
            return l1;
        if(l1->val < l2->val){
            l1->next =  mergeTwoLists(l1->next, l2);
            return l1;
        }else{
            l2->next = mergeTwoLists(l2->next, l1);
            return l2;
        }
    }
};

查看官方题解之后发现上述的if判断过多，应该改为if - else if - else结构，因为每次递归都指挥进入一条if里面，但是判断过程过多：

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(l2->next, l1);
            return l2;
        }
    }
};