21. 合并两个有序链表

题目来源：合并两个有序链表

 题目如上。由于太长时间没有做数据结构的题目了，乍一看到这道题有思路，但是细节方面做的很不好，还是要多加练习啊。

先来看一下我的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if((!l1) && (!l2))return NULL;
        ListNode* newList = new ListNode();
        ListNode* temp = newList;
        while(l1 && l2)
        {
            ListNode* t = new ListNode;
            temp->next = t;
            temp = t;  
            if(l1->val < l2->val)
            {
                temp->val = l1->val;
                l1 = l1->next;
            }
            else
            {
                temp->val = l2->val;
                l2 = l2->next;
            }    
     
        }
        while(l1)
        {
            ListNode* t = new ListNode;
            temp->next = t;
            temp = t;
            temp->val = l1->val;
            l1 = l1->next;
        }
        while(l2)
        {
            ListNode* t = new ListNode;
            temp->next = t;
            temp = t;
            temp->val = l2->val;
            l2 = l2->next;
        }
        return newList->next;
    }
};

可以用一个惨不忍睹来形容，代码很多，而且大多数是无效代码，思路很简单，但是做的很不好，我就不讲解这个代码了，实在是不好意思说。

然后展示一下正常的代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* head = new ListNode;
        ListNode* temp = head;
        while(l1 && l2)
        {
            if(l1->val < l2->val){
                temp->next = l1;
                l1 = l1->next;
            }
            else
            {
                temp->next = l2;
                l2 = l2->next;
            }
            temp = temp->next;
        }
        temp->next = (l1 == NULL ? l2 : l1);
        return head->next;
    }
};

思路就是遍历两个链表，遇到小的就让temp->next指向它。

另外一种就是递归的思路，我们要合并链表，只有以下两种情况：

 此时递归的思路就体现出来了

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
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;
        }
    }
};

 乍一看挺简单的，但是仔细一想，真正的修改操作在哪里体现呢？

递归，就是用栈的原理实现的，当我对第一个数字排序的时候，我还不知道后面的是怎么排序的，所以先把第一个放到栈里，然后对剩下的排序，依次往后入栈，直到最后有一个链表为空，此时再依次出栈。