《剑指Offer——合并两个排序的链表,两个链表的第一个公共节点》代码

Posted 2021-10-25 穿迷彩服的鲨鱼

25.合并两个排序的链表,52两个链表的第一个公共节点

• 前言
• 一、示例
• • 1.合并两个排序的链表
  • 2.两个链表的第一个公共节点
• 二、代码解析
• • 1.新建.cpp文件
  • • 代码如下（示例）：
• 三，测试

---

前言

//==================================================================
// 《剑指Offer——合并两个排序的链表,两个链表的第一个公共节点》代码
// 题目：输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按
// 照递增排序的。例如输入图3.11中的链表1和链表2，则合并之后的升序链表如链
// 表3所示。
// =================================================================
// 题目：输入两个链表，找出它们的第一个公共结点。
//==================================================================

---

一、示例

1.合并两个排序的链表

/*********************************************************************
/*
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
*/
***********************************************************************/

2.两个链表的第一个公共节点

/******************************************************************************
/*
输入两个链表，找出它们的第一个公共节点。
*/
*************************************************************************/

二、代码解析

1.新建.cpp文件

代码如下（示例）：

//==================================================================
// 《剑指Offer——合并两个排序的链表,两个链表的第一个公共节点》代码
// 题目：输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按
// 照递增排序的。例如输入图3.11中的链表1和链表2，则合并之后的升序链表如链
// 表3所示。
// =================================================================
// 题目：输入两个链表，找出它们的第一个公共结点。
//==================================================================



#include <iostream>
#include<stack>
using namespace std;

struct ListNode
{
	int val;
	ListNode* next;
};

/*
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
*/
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
{
	if (l1 == nullptr)
	{
		return l2;
	}
	else if (l2 == nullptr)
	{
		return l1;
	}

	ListNode* pNode = nullptr;
	if (l1->val < l2->val)
	{
		pNode = l1;
		pNode->next = mergeTwoLists(l1->next, l2);
	}
	else
	{
		pNode = l2;
		pNode->next = mergeTwoLists(l1, l2->next);
	}
	return pNode;
}

/*
输入两个链表，找出它们的第一个公共节点。
*/
/*法一----双栈*/
ListNode* getIntersectionNode1(ListNode* headA, ListNode* headB)
{
	ListNode* pNode = nullptr;
	stack<ListNode*> stack1;
	stack<ListNode*> stack2;
	if (headA == nullptr || headB == nullptr)
	{
		return pNode;
	}
	while (headA != nullptr)
	{
		stack1.push(headA);

		headA = headA->next;
	}
	while (headB != nullptr)
	{
		stack2.push(headB);

		headB = headB->next;
	}
	while (!stack1.empty() && !stack2.empty())
	{
		if (stack1.top() == stack2.top())
		{
			pNode = stack1.top();
			stack1.pop();
			stack2.pop();
		}
		else
		{
			break;
		}
	}

	return pNode;
}

/*法二----你长你先走（先走一步）*/
unsigned int GetListLength(ListNode* pHead)
{
	unsigned int len = 0;
	ListNode* pNode = pHead;
	while (pNode != nullptr)
	{
		++len;
		pNode = pNode->next;
	}
	return len;
}

ListNode* getIntersectionNode(ListNode* headA, ListNode* headB)
{
	//得到两个链表的长度
	unsigned int longList = GetListLength(headA);
	unsigned int shortList = GetListLength(headB);
	unsigned int dValue = longList - shortList;

	ListNode* pLongNode = headA;
	ListNode* pShortNode = headB;

	if (shortList > longList)
	{
		pLongNode = headB;
		pShortNode = headA;
		dValue = shortList - longList;
	}

	//现在长脸表上走几步
	for (int i = 0; i < dValue; ++i)
	{
		pLongNode = pLongNode->next;
	}

	while (pLongNode != nullptr && pShortNode != nullptr && pShortNode != pLongNode)
	{
		pLongNode = pLongNode->next;
		pShortNode = pShortNode->next;
	}
	//得到第一个公共节点
	ListNode* resNode = pLongNode;
	return resNode;
}

int main()
{
	std::cout << "Hello World!\\n";
}

三，测试