easy 合并两个有序链表 链表

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

---

链表 暴力搜索：

c++

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}   // 数据域为val
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {  // 传入指向l1 l2链表首结点的指针
        ListNode dummy = ListNode(-1);  // 新链表 val=-1
        ListNode *prev = &dummy;   // 指针指向新链表首结点

        while(l1 != nullptr && l2 != nullptr){  //  l1 l2 指向两个输入的升序链表  均 头节点指针不为空时
            if(l1->val < l2->val){  // l1 首节点值小
                prev->next = l1;    // 新链表指针指向 该l1 首节点
                l1 = l1->next;
            }else{
                prev->next = l2;
                l2 = l2->next;
            }
            prev = prev->next;  // 此时指针prev仍指向 新链表首结点，将指针后移到l1 l2中小的首节点
        }
        // 跳出while循环时，l1 l2 一定有一个为空
        prev->next =  (l1 == nullptr)? l2:l1;  // l1 为空时，返回l2 prev->next = l2
                                   // l1 不为空时(l2肯定为空)，返回l1 prev->next = l1

        return dummy.next;  // dummy链表首结点值放了-1，首结点后的链表才是排序后的链表
    }
};

---

python

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

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:

        prehead = ListNode(-1)  #  新链表 val=-1
        prev = prehead   #  比较指针初始指向 新链表 头节点

        while l1 and l2:  # l1 l2 不为空链表
            if l1.val < l2.val:
                prev.next = l1  # 新链表头指针 指向 目前l1头节点
                l1 = l1.next    # l1 头节点后移
            else:
                prev.next = l2
                l2 = l2.next 
            prev = prev.next  # 移动比较指针到 l1 l2 小的头节点上

        # 跳出while循环时，l1 l2 一定有一个为空
        prev.next = l1 if l1 is not None else l2

        return prehead.next

---

链表 递归 ：

跳出递归条件：l1 l2 有一个为空，则返回另一个链表的 “头指针” 给上一层调用的递归函数！
而递归函数的结果会赋给 l1 or l2 —>next，并且 return l1 or l2 头指针，此时返回的链表，头指针后接着的链表是已返回的递归函数结果：链表
该新链表：头指针+头指针后的链表，返回给又上一层递归函数作为 l1 or l2 —>next 。。。

c++

/**
 * 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) {  // 函数 mergeTwoLists
        // 跳出条件
        if(l1 == nullptr){  // 空链表，空头指针
            return l2;  // 返回头指针
        }
        if(l2 == nullptr){
            return l1;  // 返回头指针
        }

        // 递归循环条件
        if(l1->val < l2->val){   // l1 的头节点值小
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;  // 返回头指针
        }else{
            l2->next = mergeTwoLists(l1, l2->next);
            return l2;  // 返回头指针
        }
    }
};

---

python

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:

        if not l1:
            return l2
        if not l2:
            return l1

        if l1.val < l2.val:
            l1.next = self.mergeTwoLists(l1.next, l2)  # l1头节点值小，比较l1头节点之后的链表和l2，返回较小的链表，作为当前l1头节点之后的链表
            return l1                                  # 返回l1的头节点
        else:
            l2.next = self.mergeTwoLists(l1, l2.next)
            return l2

---

c++ 链表: Node->next 等价于 Node.next