@TOC

:strawberry: 小边碎碎念：莓错，这里是日更古早题解的小边。说古早，是因为这些题目两个月前就做过一遍了，趁最近清闲重新做一遍复习一下，顺便把博客维护起来。

正文开始@边通书

这两道题目，都采用了相似的思想 —— “归并”，即 ——
比较两个有序序列最前面的数字，谁小就先取谁，取后相应的“指针”就往后移动一位。

在后序的归并排序中这个思想还要继续运用:innocent:。

1. 合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况， nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。 nums2 的长度为 n

示例1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] 

示例2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1]

题目链接：合并两个有序数组

:key: 思路

对于本题，要求合并后的数组存储在nums1中。为了使数据不被覆盖，我们灵活地想到，从数组尾开始做比较，取大的数下来。

整个过程很简单 ——

快进到最后寻找终止条件 ——

:strawberry:唯一要注意的是，两个数组谁先结束 ——
若在nums2这边先结束，那就不用管了（如上）；
若nums1先结束，则需要将nums2剩余数据拷贝过来。（这都是基于本题是合并后的数据存储在nums1中）

比如像这样的数组 —— 过程很简单，自己画就行，在这儿我还是直接快进到最后了

:key:完整代码 ——

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    int end = m + n - 1;
    int end1 = m - 1;
    int end2 = n - 1;
    while(end1>=0 && end2>=0)
    {
        if(nums1[end1]>nums2[end2])
        {
            nums1[end] = nums1[end1];
            end1--;
        }
        else
        {
            nums1[end] = nums2[end2];
            end2--;
        }
        end--;
    }

    //若先在nums1结束，需要把nums2中的数字拷贝过来
    while(end2>=0)
    {
        nums1[end--] = nums2[end2--];
    }
}

2. 合并两个有序链表

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

示例1：
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例2：
输入：l1 = [], l2 = []
输出：[]
示例3：
输入：l1 = [], l2 = [0]
输出：[0]

题目链接：合并两个有序链表

思路和上一题差不多，只不过载体不一样罢了。
在这儿我就不画图了，我把要注意的小点都写好了，自己画是最清晰的

:strawberry: 注意我们开一个哨兵位节点，方便尾插 ；最后别忘free掉 ，防止内存泄漏—— 这样避免了尾插中，上来处理第一个节点的麻烦（题目中经常这样做）。
:strawberry: 最后剩余的元素直接链过来就行
:strawberry: 别忘了最后返回的是head->next，而不是head这个不存有效数据的头。

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    if(list1==NULL && list2==NULL)
        return NULL;
    if(list1 == NULL)
        return list2;
    if(list2 == NULL)
        return list1;

    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));//开一个带哨兵位的节点
    struct ListNode* tail = head;

    while(list1 && list2)
    {
        if(list1->val <list2->val)
        {
            tail->next = list1;
            list1 = list1->next;
        }
        else
        {
            tail->next = list2;
            list2 = list2->next;
        }
        tail = tail->next;
    }

    if(list1)
    {
        tail->next = list1;
    }

    if(list2)
    {
        tail->next = list2;
    }
    struct ListNode* pList = head->next;
    free(head);//防止内存泄漏
    return pList;
}

这里再提供一种写法 —— 合并为无头单链表

本质一样，就是相比于上一种写法，还要处理一下针对空链表的插入，这也让我们体会到了带哨兵位的单链表的优势。

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    if(list1 == NULL && list2 == NULL)
        return NULL;
    if(list1 == NULL)
        return list2;
    if(list2 == NULL)
        return list1;

    //1.处理空链表的插入 
    //假设法 - 假设就是第一个链儿的首元素的val比第二个链儿小
    struct ListNode* pList = list1;
    if(list1->val > list2->val)
    {
        pList = list2;
        list2 = list2->next;
    }
    else
    {
        list1 = list1->next;
    }


    //2.
    struct ListNode* tail = pList;
    while(list1 && list2)
    {
        if(list1->val < list2->val)
        {
            tail->next = list1;
            list1 = list1->next;
        }
        else
        {
            tail->next = list2;
            list2 = list2->next;
        }
        tail = tail->next;
    }

    //剩余元素的直接链接过来就行了
    if(list1)
    {
        tail->next = list1;
    }

    if(list2)
    {
        tail->next = list2;
    }
    return pList;
}