算法 合并有序序列（逆向双指针/穿线法/归并法）

一、合并有序数组

1.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] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：

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

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

1.2 代码

/*
观察可知 nums1 的后半部分是空的，可以直接覆盖而不会影响结果。
因此可以指针设置为从后向前遍历，每次取两者之中的较大者放进 nums1 的最后面。
*/
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){

	int idx_one = m - 1, idx_two = n - 1;
	int iter = m + n - 1;
	while(idx_one >= 0 && idx_two >= 0)
	{
		if(nums1[idx_one] < nums2[idx_two])
		{
			nums1[iter--] = nums2[idx_two--];
		}
		else
		{
			nums1[iter--] = nums1[idx_one--];
		}
	}

	
	//方法一
	if(idx_two >=  0)
	{
		memcpy(nums1, nums2, (idx_two + 1)*sizeof(int));
	}
	
	
	/*//方法二
	while(idx_two >= 0)
	{
		nums1[iter--] = nums2[idx_two--];
	}
	*/
}

---

二、合并有序链表

2.1 题意

题目链接

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

示例 1：

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

输入：l1 = [], l2 = []
输出：[]
示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

2.2 穿线法

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){

	if( !list1 || !list2) return !list1 ? list2 : list1;

	struct ListNode head = {0, NULL};
	struct ListNode *iter = &head;

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

		iter = iter->next;
	}

	if(list1)
	{
		iter->next = list1;
	}
	else
	{
		iter->next = list2;
	}

	return head.next;
}

---

三、合并排序链表

3.1 题意

题目链接

给定一个链表数组，每个链表都已经按升序排列。

请将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
示例 2：

输入：lists = []
输出：[]
示例 3：

输入：lists = [[]]
输出：[]

3.2 题解

3.2.1

//方法一：多个链表划分为每每两个链表的合并
struct ListNode* mergeTwoLists(struct ListNode* list1,struct ListNode* list2)
{
	if(!list1 || !list2)
	{
		return (!list1) ? list2 : list1;
	}

	struct ListNode head = {0, NULL};
	struct ListNode* iter = &head;

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

		iter = iter->next;
	}

	if(list1)
	{
		iter->next = list1;
	}
	else
	{
		iter->next = list2;
	}

	return head.next;
}

struct ListNode* mergeKLists(struct ListNode** lists, int listsSize){

	if(!lists || listsSize == 0) return NULL;

	if(listsSize == 1)  return lists[0];

	struct ListNode head = {0, NULL};
	
	for(int i = 0; i < listsSize; i++)
	{
		head.next = mergeTwoLists(head.next, lists[i]);
	}

	return head.next;

}

3.2.2 归并法

//方法二 分治法 类比归并排序
struct ListNode* mergeTwoLists(struct ListNode* list1,struct ListNode* list2)
{
	if(!list1 || !list2)
	{
		return (!list1) ? list2 : list1;
	}

	struct ListNode head = {0, NULL};
	struct ListNode* iter = &head;

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

		iter = iter->next;
	}

	if(list1)
	{
		iter->next = list1;
	}
	else
	{
		iter->next = list2;
	}

	return head.next;
}


struct ListNode* merge(struct ListNode** lists, int left, int right)
{
	if(left == right)
	{
		return lists[left];
	}
	else if(left + 1 == right)
	{
		return mergeTwoLists(lists[left], lists[right]);
	}

	int mid = left + (right - left)/2;

	struct ListNode* left_merge = merge(lists, left, mid-1);
	struct ListNode* right_merge = merge(lists, mid, right);

	return mergeTwoLists(left_merge, right_merge);
}


struct ListNode* mergeKLists(struct ListNode** lists, int listsSize){

	if(!lists || listsSize == 0) return NULL;

	if(listsSize == 1)  return lists[0];

	return merge(lists, 0, listsSize-1);

}