【剑指】25.合并两个排序的链表

题目描述

• 输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按照递增排序的。

算法分析

• 迭代法：两个链表中较小的头结点作为合并后头结点，之后依次合并两个链表中较小的结点，以此类推，最终合并剩余结点；
• 递归法：两个链表中较小的头结点作为合并后头结点，递归；

提交代码：

class Solution {
public:
	ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
	{
		if (!pHead1)
			return pHead2;
		if (!pHead2)
			return pHead1;

		if (pHead1->val < pHead2->val)
			pHead1->next = Merge(pHead1->next, pHead2);
		else
			pHead2->next = Merge(pHead1, pHead2->next);

		return pHead1->val < pHead2->val ? pHead1 : pHead2;

	}

	ListNode* Merge2(ListNode* pHead1, ListNode* pHead2)
	{
		if (!pHead1)
			return pHead2;

		if (!pHead2)
			return pHead1;

		/* 创建新的头结点 */
		//ListNode* newHead = new ListNode(-1);
		//ListNode* currNode = newHead;
		ListNode* p1 = pHead1;
		ListNode* p2 = pHead2;

		ListNode* currNode;
		if (p1->val < p2->val)
		{
			currNode = p1;
			p1 = p1->next;
		}
		else
		{
			currNode = p2;
			p2 = p2->next;
		}

		ListNode* newHead = currNode;

		while (p1 && p2)
		{
			if (p1->val < p2->val)
			{
				currNode->next = p1;
				p1 = p1->next;
			}
			else
			{
				currNode->next = p2;
				p2 = p2->next;
			}
			currNode = currNode->next;
		}

		while (p1)
		{
			currNode->next = p1;
			currNode = currNode->next;
			p1 = p1->next;
		}

		while (p2)
		{
			currNode->next = p2;
			currNode = currNode->next;
			p2 = p2->next;
		}

		// return newHead->next;
		return newHead;
	}
};

测试代码：

// ====================测试代码====================
ListNode* Test(char* testName, ListNode* pHead1, ListNode* pHead2)
{
	if (testName != nullptr)
		printf("%s begins:\n", testName);

	printf("The first list is:\n");
	PrintList(pHead1);

	printf("The second list is:\n");
	PrintList(pHead2);

	printf("The merged list is:\n");
	Solution s;
	ListNode* pMergedHead = s.Merge(pHead1, pHead2);
	PrintList(pMergedHead);

	printf("\n\n");

	return pMergedHead;
}

// list1: 1->3->5
// list2: 2->4->6
void Test1()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode5 = CreateListNode(5);

	ConnectListNodes(pNode1, pNode3);
	ConnectListNodes(pNode3, pNode5);

	ListNode* pNode2 = CreateListNode(2);
	ListNode* pNode4 = CreateListNode(4);
	ListNode* pNode6 = CreateListNode(6);

	ConnectListNodes(pNode2, pNode4);
	ConnectListNodes(pNode4, pNode6);

	ListNode* pMergedHead = Test("Test1", pNode1, pNode2);

	DestroyList(pMergedHead);
}

// 两个链表中有重复的数字
// list1: 1->3->5
// list2: 1->3->5
void Test2()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode5 = CreateListNode(5);

	ConnectListNodes(pNode1, pNode3);
	ConnectListNodes(pNode3, pNode5);

	ListNode* pNode2 = CreateListNode(1);
	ListNode* pNode4 = CreateListNode(3);
	ListNode* pNode6 = CreateListNode(5);

	ConnectListNodes(pNode2, pNode4);
	ConnectListNodes(pNode4, pNode6);

	ListNode* pMergedHead = Test("Test2", pNode1, pNode2);

	DestroyList(pMergedHead);
}

// 两个链表都只有一个数字
// list1: 1
// list2: 2
void Test3()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode2 = CreateListNode(2);

	ListNode* pMergedHead = Test("Test3", pNode1, pNode2);

	DestroyList(pMergedHead);
}

// 一个链表为空链表
// list1: 1->3->5
// list2: 空链表
void Test4()
{
	ListNode* pNode1 = CreateListNode(1);
	ListNode* pNode3 = CreateListNode(3);
	ListNode* pNode5 = CreateListNode(5);

	ConnectListNodes(pNode1, pNode3);
	ConnectListNodes(pNode3, pNode5);

	ListNode* pMergedHead = Test("Test4", pNode1, nullptr);

	DestroyList(pMergedHead);
}

// 两个链表都为空链表
// list1: 空链表
// list2: 空链表
void Test5()
{
	ListNode* pMergedHead = Test("Test5", nullptr, nullptr);
}

int main(int argc, char* argv[])
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();

	return 0;
}