leetcode 21 合并两个有序链表

思路并不困难，一个循环就行了。每一次循环的目标为找到当前最小的数字，找到之后就使该链表的temp节点向后。又因为两个提供的链表都是升序，所以每次循环只需要对比两个temp节点对应的数据即可，问题不大。下面贴代码

/**
 * 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* temp1 = l1;
        ListNode* temp2 = l2;
        ListNode* head = new ListNode();
        ListNode* temp3 = head;
        while(temp1 || temp2)
        {
            if(temp1 && temp2 && (temp1->val < temp2->val))
            {
                ListNode* Node = new ListNode(temp1->val);
                temp3->next = Node;
                temp3 = Node;
                temp1 = temp1->next;             //删除已经录入的节点
            }
            else if(temp1 && temp2 && (temp1->val > temp2->val))
            {
                ListNode* Node = new ListNode(temp2->val);   
                temp3->next = Node;
                temp3 = Node;   
                temp2 = temp2->next;             //删除已经录入的节点 
            }
            else if(temp1 && temp2 && (temp1->val == temp2->val))
            {
                ListNode* Node1 = new ListNode(temp1->val); 
                ListNode* Node2 = new ListNode(temp2->val); 
                temp3->next = Node1;
                Node1->next = Node2;
                temp3 = Node2;
                temp1 = temp1->next;             //删除已经录入的节点
                temp2 = temp2->next;             //删除已经录入的节点
            }
            else if(temp1)
            {
                ListNode* Node = new ListNode(temp1->val);
                temp3->next = Node;
                temp3 = Node;
                temp1 = temp1->next;             //删除已经录入的节点    
            }
            else
            {
                ListNode* Node = new ListNode(temp2->val);   
                temp3->next = Node;
                temp3 = Node;   
                temp2 = temp2->next;             //删除已经录入的节点    
            }
        }
        return head->next;                                     
    }
};

 有个递归写法，属实牛皮，直接在原始的两个连表上操作，连空间都不用new，下面贴代码

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

中心思想就是判断当前l1与l2的val的大小，然后通过调用该函数再次进行比较。如果遇到l1或者l2为NULL，则代表不需要再进行比较，直接返回剩下一个链表的内容就行。如此一来也完成了排序，很巧妙的做法。