【leetcode】21. 合并两个有序链表(Merge Two Sorted Lists)

---

题目描述

【leetcode】21. 合并两个有序链表(Merge Two Sorted Lists))
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

第一次解答

思路：
链表都是有序的
我把第二个链表，有序的插入到第一个链表中，得到结果。
为了更方便，我们把两个链表中第一个元素小的那个作为基准，
把另一个链表插入基准中。

p1指向链表L1的第1个元素，链表L1第一个元素是较小的那个。
p2指向链表L2的第1个元素
那么只有两种情况
如果p2>p1 && (p2 <= p1->next 或 p1->next为空), p2插入到p1后面
如果p2>p1 && p2 > p1->next, p1=p1->next

注意：
输入指针为空的情况
链表为空的情况
链表下个元素为空的情况
如果基准的下个元素为空，那就可以完全把整个链表插入到基准后面

**test case:**每两行为一个测试用例
[1,2,4]
[1,3,4]
[1,1,1, 2, 4]
[1,1,2, 3, 4]
[]
[1,1,2, 3, 4]

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include <iostream>
 using namespace std;
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {

        if(nullptr == l1 && nullptr == l2)
        {
            return nullptr;
        }
        if(nullptr == l1)
        {
            return l2;
        }
        if(nullptr == l2)
        {
            return l1;
        }
            
        ListNode *p_result = nullptr;
        ListNode *p_base = nullptr;
        ListNode *p_other = nullptr;
        if(l1->val >= l2->val){
            p_base = l2;
            p_other = l1;
        }
        else{
            p_base = l1;
            p_other = l2;
        }
        p_result = p_base;
        while(nullptr != p_other){
            
            if(nullptr == p_base->next){
                p_base->next = p_other;
                // break;
                return p_result;
            }
            // if(p_other->val >= p_base->val && p_other->val < p_base->next->val )
            if(p_other->val < p_base->next->val ) // 只要上面初始化好，与坐标的条件一定满足
            {
                cout << "1" <<endl;
                //插入
                ListNode *p_other_next = p_other->next;
                p_other->next = p_base->next;
                p_base->next = p_other;
                //遍历下一个元素
                p_other = p_other_next;
                p_base = p_base->next;
            }
            // else if(p_other->val >= p_base->val && p_other->val >= p_base->next->val )
            // else if(p_other->val >= p_base->next->val )
            else
            {
                //遍历下一个元素
                p_base = p_base->next;
            }
        }



        return p_result;
    }
};

结果：

第二次解答

看了解答，发现解答一可以优化为更简洁的想法。
思路：
新建一个指针head
遍历两个链表，谁的元素小我就指向谁。
最后返回结果的是head->next。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
 #include <iostream>
 using namespace std;
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {

        if(nullptr == l1 && nullptr == l2)
        {
            return nullptr;
        }
        if(nullptr == l1)
        {
            return l2;
        }
        if(nullptr == l2)
        {
            return l1;
        }
        ListNode *p_head = new ListNode(0);
        ListNode *p_pre = p_head;


        while(nullptr != l1 && nullptr != l2){

            if(l1->val < l2->val ) 
            {
                p_pre->next = l1;
                p_pre = p_pre->next;
                l1 = l1->next;
            }
        
            else
            {
                p_pre->next = l2;
                p_pre = p_pre->next;
                l2 = l2->next;
            }
        }


        p_pre->next = (nullptr == l1 ? l2 : l1);
        return p_head->next;
    }
};

结果：

第3次解答

采用递归的方法实现，代码更简洁。

相关/参考链接