复杂链表的复制

最新推荐文章于 2023-06-16 13:23:16 发布
最新推荐文章于 2023-06-16 13:23:16 发布
阅读量677 收藏
点赞数
分类专栏： 面试题

转自：http://zhedahht.blog.163.com/blog/static/254111742010819104710337/


     题目：有一个复杂链表，其结点除了有一个m_pNext指针指向下一个结点外，还有一个m_pSibling指向链表中的任一结点或者NULL。其结点的C++定义如下：

struct ListNode
{
	int m_nvalue;
	ListNode* m_pNext;
	ListNode* m_pSibling;
};

   下图是一个含有5个结点的该类型复杂链表。图中实线箭头表示m_pNext指针，虚线箭头表示m_pSibling指针。为简单起见，指向NULL的指针没有画出。

                                     程序员面试题精选100题(49)-复杂链表的复制 - 何海涛 - 微软、Google等面试题

                

请完成函数 ListNode* ComplexListCopy(ListNode* pHead) ，以复制一个复杂链表。

                分析：在常见的数据结构上稍加变化，这是一种很新颖的面试题。要在不到一个小时的时间里解决这种类型的题目，我们需要较快的反应能力，对数据结构透彻的理解以及扎实的编程功底。

           看到这个问题，我的第一反应是分成两步：第一步是复制原始链表上的每个节点，并用m_pNext链接起来。第二步，假设原始链表中的某节点N的m_pSibling指向结点S。由于S的位置在链表上有可能在N的前面也可能在N的后面，所以要定位N的位置我们需要从原始链表的头结点开始找。假设从原始链表的头结点开始经过s步找到结点S。那么在复制链表上结点N的m_pSibling的S’，离复制链表的头结点的距离也是s。用这种办法我们就能为复制链表上的每个结点设置m_pSibling了。

代码如下：

#include <iostream>
#include <stdio.h>

using namespace std;

struct ListNode
{
	int m_nvalue;
	ListNode* m_pNext;
	ListNode* m_pSibling;
};

void CopySibling(ListNode* pHead1,ListNode* pHead2);

ListNode* ComplexListCopy(ListNode* pHead)
{
	//第一步是复制原始链表上的每个节点，并用m_pNext链接起来，m_pSibling先置为NULL。

	if(NULL == pHead)
		return NULL;
	ListNode* pCopyHead;
	ListNode* pNode = pHead;
	ListNode* pCopyNode = new ListNode();
	if(NULL == pCopyNode)
	{
		printf("No more memory\n");
		return NULL;
	}
	pCopyNode->m_nvalue = pNode->m_nvalue;
	pCopyNode->m_pNext = pCopyNode->m_pSibling = NULL;
	pCopyHead = pCopyNode;
	ListNode* tmpNode = pCopyHead;
	pNode = pNode->m_pNext;
	while(NULL != pNode)
	{
		ListNode* pCopyNode = new ListNode();
		if(NULL == pCopyNode)
		{
			printf("No more memory\n");
			return NULL;
		}
		pCopyNode->m_nvalue = pNode->m_nvalue;
		pCopyNode->m_pNext = pCopyNode->m_pSibling = NULL;
		tmpNode->m_pNext = pCopyNode;
		tmpNode = pCopyNode;
		pNode = pNode->m_pNext;
	}

	//第二步，复制m_pSibling域的值
	CopySibling(pHead,pCopyHead);
	
	return pCopyHead;
}

/*第二步，假设原始链表中的某节点N的m_pSibling指向结点S。由于S的位置在链表上有可能在N的前面也可能在N的后面，
所以要定位N的位置我们需要从原始链表的头结点开始找。假设从原始链表的头结点开始经过s步找到结点S。
那么在复制链表上结点N的m_pSibling的S’，离复制链表的头结点的距离也是s。用这种办法我们就能为复制链表上的每个结点设置m_pSibling了。*/
void CopySibling(ListNode* pHead1,ListNode* pHead2)
{
	if(NULL == pHead1 || NULL == pHead2)
		return;
	ListNode* tmpNode1;
	ListNode* tmpNode2;
	ListNode* pNode1 = pHead1;
	ListNode* pNode2 = pHead2;
	while(NULL != pNode1)
	{
		if(pNode1->m_pSibling != NULL)
		{/*复制m_pSibling域的值时，每次都是从链表的头部开始查找*/
			tmpNode1 = pHead1;
			tmpNode2 = pHead2;
			while(tmpNode1->m_nvalue != pNode1->m_pSibling->m_nvalue)
			{
				//复制链表的指针与原始链表的指针同时移动。
				tmpNode1 = tmpNode1->m_pNext;
				tmpNode2 = tmpNode2->m_pNext;
			}
			pNode2->m_pSibling = tmpNode2;
		}
		pNode1 = pNode1->m_pNext;
		pNode2 = pNode2->m_pNext;
	}
}

//依据m_pNext域的值从头打印链表
void Print(ListNode* pHead)
{
	if(NULL == pHead)
		return;
	while(pHead)
	{
		printf("%d ",pHead->m_nvalue);
		pHead = pHead->m_pNext;
	}
	printf("\n");
}
//依据m_pSibling域的值从头打印链表
void PrintSiblingOrder(ListNode* pHead)
{
	if(NULL == pHead)
		return;
	while(pHead)
	{
		if(pHead->m_pSibling != NULL)
			printf("%d ",pHead->m_pSibling->m_nvalue);
		pHead = pHead->m_pNext;
	}
	printf("\n");
}

int main()
{	
	/*构造复杂链表*/
	ListNode* pHead = NULL;
	ListNode* pHead2 = NULL;
	ListNode* tmpNode1 = new ListNode();
	if(NULL == tmpNode1)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode1->m_nvalue = 1;
	tmpNode1->m_pNext = tmpNode1->m_pSibling = NULL;
	pHead = tmpNode1;
	ListNode* tmpNode2 = new ListNode();
	if(NULL == tmpNode2)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode2->m_nvalue = 2;
	tmpNode2->m_pNext = tmpNode2->m_pSibling = NULL;
	tmpNode1->m_pNext = tmpNode2;
	ListNode* tmpNode3 = new ListNode();
	if(NULL == tmpNode3)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode3->m_nvalue = 3;
	tmpNode3->m_pNext = tmpNode2->m_pSibling = NULL;
	tmpNode2->m_pNext = tmpNode3;
	ListNode* tmpNode4 = new ListNode();
	if(NULL == tmpNode4)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode4->m_nvalue = 4;
	tmpNode4->m_pNext = tmpNode4->m_pSibling = NULL;
	tmpNode3->m_pNext = tmpNode4;

	tmpNode1->m_pSibling = tmpNode3;
	tmpNode2->m_pSibling = tmpNode4;
	tmpNode3->m_pSibling = tmpNode1;
	tmpNode4->m_pSibling = tmpNode2;
	
	//依据m_pSibling域的值从头打印原始链表
	PrintSiblingOrder(pHead);
	
	pHead2 = ComplexListCopy(pHead);
	//依据m_pSibling域的值从头打印复制链表
	PrintSiblingOrder(pHead2);

	return 0;
}

                对一个含有n个结点的链表，由于定位每个结点的m_pSibling，都需要从链表头结点开始经过O(n)步才能找到，因此这种方法的总时间复杂度是O(n2)。

                由于上述方法的时间主要花费在定位结点的m_pSibling上面，我们试着在这方面去做优化。我们还是分为两步：第一步仍然是复制原始链表上的每个结点N，并创建N’，然后把这些创建出来的结点链接起来。这里我们对<N，N’>的配对信息放到一个哈希表中。第二步还是设置复制链表上每个结点的m_pSibling。如果在原始链表中结点N的m_pSibling指向结点S，那么在复制链表中，对应的N’应该指向S’。由于有了哈希表，我们可以用O(1)的时间根据S找到S’。

                第二种方法相当于用空间换时间，以O(n)的空间消耗实现了O(n)的时间效率。

                接着我们来换一种思路，在不用辅助空间的情况下实现O(n)的时间效率。第三种方法的第一步仍然是根据原始链表的每个结点N，创建对应的N’。这一次，我们把N’链接在N的后面。实例中的链表经过这一步之后变成了：

                                                     程序员面试题精选100题(49)-复杂链表的复制 - 何海涛 - 微软、Google等面试题
代码如下： 
//第一步仍然是根据原始链表的每个结点N，创建对应的N’。这一次，我们把N’链接在N的后面,复制的节点的m_pSibling域置为NULL
bool CopyAndMergeList(ListNode* pHead)
{
	if(NULL == pHead)
	{
		invaluedInput = true;
		return false;
	}

	ListNode* pTmpNode = NULL;
	ListNode *pNode = pHead->m_pNext;
	ListNode* newNode = new ListNode();
	assert(NULL != newNode);
	newNode->m_nvalue = pHead->m_nvalue;
	newNode->m_pNext = pHead->m_pNext;
	newNode->m_pSibling = NULL;
	pHead->m_pNext = newNode;
	pTmpNode = pNode;
	while(pNode != NULL)
	{
		pNode = pNode->m_pNext;
		newNode = new ListNode();
		assert(NULL != newNode);
		newNode->m_nvalue = pTmpNode->m_nvalue;
		newNode->m_pNext = pTmpNode->m_pNext;
		newNode->m_pSibling = NULL;
		pTmpNode->m_pNext = newNode;
		pTmpNode = pNode;
	}
	return true;
}

       第二步是设置我们复制出来的链表上的结点的m_pSibling。假设原始链表上的N的m_pSibling指向结点S，那么其对应复制出来的程序员面试题精选100题(49)-复杂链表的复制 - 何海涛 - 微软、Google等面试题N’是N->m_pNext，同样S’也是S->m_pNext。这就是我们在上一步中把每个结点复制出来的结点链接在原始结点后面的原因。有了这样的链接方式，我们就能在O(1)中就能找到每个结点的m_pSibling了。例子中的链表经过这一步，就变成如下结构了：

                                                                程序员面试题精选100题(49)-复杂链表的复制 - 何海涛 - 微软、Google等面试题 
//设置上一步复制出来的链表上的结点的m_pSibling域，返回值为复制链表的头结点指针
ListNode* Copym_pSibling(ListNode* pHead)
{
	if(NULL == pHead)
	{
		invaluedInput = true;
		return NULL;
	}

	ListNode* pNode = pHead;
	ListNode* pCopyNode = pHead->m_pNext;
	while(pNode != NULL)
	{
		pCopyNode->m_pSibling = pNode->m_pSibling->m_pNext;
		pNode = pNode->m_pNext->m_pNext;
		if(NULL == pNode)
			break;
		pCopyNode = pCopyNode->m_pNext->m_pNext;
	}
	return pHead->m_pNext;
}

      第三步是把这个长链表拆分成两个：把奇数位置的结点链接起来就是原始链表，把偶数位置的结点链接出来就是复制出来的链表。上述例子中的链表拆分之后的两个链表如下：

                                                程序员面试题精选100题(49)-复杂链表的复制 - 何海涛 - 微软、Google等面试题 
//第三步是把这个长链表拆分成两个：把奇数位置的结点链接起来就是原始链表，把偶数位置的结点链接出来就是复制出来的链表。返回复制链表的头指针
ListNode* BreakList(ListNode* pHead)
{
	if(NULL == pHead)
	{
		invaluedInput = true;
		return NULL;
	}

	ListNode* pNode = pHead;
	ListNode* pCopyHead = pHead->m_pNext;
	ListNode* pCopyNode = pCopyHead;
	ListNode* pTmpNode = NULL;
	while(pCopyNode->m_pNext != NULL)
	{
		pTmpNode = pCopyNode->m_pNext;
		pNode->m_pNext = pTmpNode;
		pCopyNode->m_pNext = pTmpNode->m_pNext;
		pNode = pTmpNode;
		pCopyNode = pTmpNode->m_pNext;
	}
	pNode->m_pNext = NULL;
	pCopyNode->m_pNext = NULL;

	return pCopyHead;
}
  我们把上面三步合起来，就是复制链表的完整过程。

下面是完整的代码（虽然将上面的代码重复贴出来显的啰嗦，但是方便自己以后复习时可以更快的回忆起整体思路。）：

#include <iostream>
#include <assert.h>
#include <stdio.h>

using namespace std;

bool invaluedInput = false;

struct ListNode
{
	int m_nvalue;
	ListNode* m_pNext;
	ListNode* m_pSibling;
};

//第一步仍然是根据原始链表的每个结点N，创建对应的N’。这一次，我们把N’链接在N的后面,复制的节点的m_pSibling域置为NULL
bool CopyAndMergeList(ListNode* pHead)
{
	if(NULL == pHead)
	{
		invaluedInput = true;
		return false;
	}

	ListNode* pTmpNode = NULL;
	ListNode *pNode = pHead->m_pNext;
	ListNode* newNode = new ListNode();
	assert(NULL != newNode);
	newNode->m_nvalue = pHead->m_nvalue;
	newNode->m_pNext = pHead->m_pNext;
	newNode->m_pSibling = NULL;
	pHead->m_pNext = newNode;
	pTmpNode = pNode;
	while(pNode != NULL)
	{
		pNode = pNode->m_pNext;
		newNode = new ListNode();
		assert(NULL != newNode);
		newNode->m_nvalue = pTmpNode->m_nvalue;
		newNode->m_pNext = pTmpNode->m_pNext;
		newNode->m_pSibling = NULL;
		pTmpNode->m_pNext = newNode;
		pTmpNode = pNode;
	}
	return true;
}

//设置上一步复制出来的链表上的结点的m_pSibling域，返回值为复制链表的头结点指针
ListNode* Copym_pSibling(ListNode* pHead)
{
	if(NULL == pHead)
	{
		invaluedInput = true;
		return NULL;
	}

	ListNode* pNode = pHead;
	ListNode* pCopyNode = pHead->m_pNext;
	while(pNode != NULL)
	{
		pCopyNode->m_pSibling = pNode->m_pSibling->m_pNext;
		pNode = pNode->m_pNext->m_pNext;
		if(NULL == pNode)
			break;
		pCopyNode = pCopyNode->m_pNext->m_pNext;
	}
	return pHead->m_pNext;
}

//第三步是把这个长链表拆分成两个：把奇数位置的结点链接起来就是原始链表，把偶数位置的结点链接出来就是复制出来的链表。返回复制链表的头指针
ListNode* BreakList(ListNode* pHead)
{
	if(NULL == pHead)
	{
		invaluedInput = true;
		return NULL;
	}

	ListNode* pNode = pHead;
	ListNode* pCopyHead = pHead->m_pNext;
	ListNode* pCopyNode = pCopyHead;
	ListNode* pTmpNode = NULL;
	while(pCopyNode->m_pNext != NULL)
	{
		pTmpNode = pCopyNode->m_pNext;
		pNode->m_pNext = pTmpNode;
		pCopyNode->m_pNext = pTmpNode->m_pNext;
		pNode = pTmpNode;
		pCopyNode = pTmpNode->m_pNext;
	}
	pNode->m_pNext = NULL;
	pCopyNode->m_pNext = NULL;

	return pCopyHead;
}

//依据m_pNext域的值从头打印链表
void Print(ListNode* pHead)
{
	if(NULL == pHead)
		return;
	while(pHead)
	{
		printf("%d ",pHead->m_nvalue);
		pHead = pHead->m_pNext;
	}
	printf("\n");
}
//依据m_pSibling域的值从头打印链表
void PrintSiblingOrder(ListNode* pHead)
{
	if(NULL == pHead)
		return;
	while(pHead)
	{
		if(pHead->m_pSibling != NULL)
			printf("%d ",pHead->m_pSibling->m_nvalue);
		pHead = pHead->m_pNext;
	}
	printf("\n");
}

int main()
{	
	/*构造复杂链表*/
	ListNode* pHead = NULL;
	ListNode* pCopyHead = NULL;
	ListNode* tmpNode1 = new ListNode();
	if(NULL == tmpNode1)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode1->m_nvalue = 1;
	tmpNode1->m_pNext = tmpNode1->m_pSibling = NULL;
	pHead = tmpNode1;
	ListNode* tmpNode2 = new ListNode();
	if(NULL == tmpNode2)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode2->m_nvalue = 2;
	tmpNode2->m_pNext = tmpNode2->m_pSibling = NULL;
	tmpNode1->m_pNext = tmpNode2;
	ListNode* tmpNode3 = new ListNode();
	if(NULL == tmpNode3)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode3->m_nvalue = 3;
	tmpNode3->m_pNext = tmpNode2->m_pSibling = NULL;
	tmpNode2->m_pNext = tmpNode3;
	ListNode* tmpNode4 = new ListNode();
	if(NULL == tmpNode4)
	{
		printf("No more memory\n");
		return NULL;
	}
	tmpNode4->m_nvalue = 4;
	tmpNode4->m_pNext = tmpNode4->m_pSibling = NULL;
	tmpNode3->m_pNext = tmpNode4;

	tmpNode1->m_pSibling = tmpNode3;
	tmpNode2->m_pSibling = tmpNode4;
	tmpNode3->m_pSibling = tmpNode1;
	tmpNode4->m_pSibling = tmpNode2;

	//复制链表的三部曲
	CopyAndMergeList(pHead);

	Copym_pSibling(pHead);

	pCopyHead = BreakList(pHead);

	//打印原始链表
	Print(pHead);
	PrintSiblingOrder(pHead);
	
	//打印复制链表
	Print(pCopyHead);
	PrintSiblingOrder(pCopyHead);

	return 0;
}
long504377009
关注
专栏目录
剑指offer～复杂链表的复制（Java）
01-20
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会...
C语言之复杂链表的复制方法(图示详解)
08-30
C语言之复杂链表的复制方法详解 一、什么是复杂链表？ 复杂链表是一种特殊的链表结构，它的每个结点不仅有一个指向下一个节点的指针，还有一个随机指针域，该指针域可以指向链表中的任意一个节点或为空结点。这种...
单链表复制
热门推荐
你好_晴天
10-24 1万+
有一单链表，已知链表长为n，现在你觉得一个不够，想自己再复制一个，以防以后下次误删，记得要用链表!  Input 输入有两行，第一行为整数n，直到n为0结束；第二行有n个数据。表长n不超过100。 Output 输出你Copy的那个链表，数据之间用空格分隔。 Sample Input 5 1 2 3 4 5 8 2 5 6 8 9 0 1 3 0  Sample Output 1 ...
复杂链表的复制问题的分析以及代码实现
hei我在这
03-12 197
对于此问题采用化解法解决， 分为三步进行： 1、先复制所有的节点链接在原来的节点后面 void CopyList(RandomListNode* pHead) { RandomListNode* pNode = pHead; while(pNode!=NULL) { ...
复杂链表复制
dadaddaddad的博客
04-02 624
问题描述： 请实现函数ComplexListNode Clone(ComplexListNode head)，复制一个复杂链表。在复杂链表中，每个结点除了有一个Next指针指向下一个结点外，还有一个Sibling指向链表中的任意结点或者NULL。 解题思路： 1.根据原始链表的每个结点N创建对应的复制节点，并添加到每个节点之后，行成一个新的链表 2. 遍历新的链表，重置复制的节点的random指针为原指针的后一个地址 3. 拆分出两个链表 package main import ( "f.
【数据结构初阶】复杂链表复制+带头双向循环链表+缓存级知识
The porters of knowledge
11-09 1122
经典的链表结构，值得你端详一下
剑指offer-链表-复杂链表复制
Stefan的博客
06-05 371
题目 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空） 思路分析 原始思路 首先从头到尾遍历链表，遍历的同时进行复制 存在问题： O(n)完成从头到尾的遍历复制，但是连接random时需要先通过遍历找到节点，导...
LeetCode 复杂链表的复制
qq_62829518的博客
06-16 289
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
33.复杂链表的复制1
08-04
【部分内容】：这段代码提供了一个解决复杂链表复制问题的算法，具体分为以下三个步骤： 1. 克隆节点并连接到原节点后面：遍历链表，对于每个节点，创建一个新的克隆节点，并将其插入到原节点之后。这样，新旧两个...
复杂链表的复制1
08-03
复杂链表的复制问题是一个经典的深度优先搜索（DFS）或广度优先搜索（BFS）问题，主要涉及链表操作和内存管理。题目要求我们复制一个具有额外随机指针的链表，其中每个节点不仅有指向下一个节点的指针，还可能有一个...
2019年计算机组装与维护实训实习报告.pdf
10-06
计算机试题试卷课件
2019年计算机维护实训总结.pdf
10-06
计算机试题试卷课件
【路径规划】基于matlab固定次序法移植路径规划（目标函数：最短距离）【含Matlab源码 8800期】.mp4
最新发布
10-06
Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
高压无桥PFC原理图PCB源代码资料
10-06
高压无桥PFC原理图PCB源代码资料
2020年计算机基础考试题ID[含答案].pdf
10-06
计算机试题试卷课件
MySQL基础语法-空间数据类型.pdf
10-06
MySQL基础语法——空间数据类型
2020年计算机操作规程.pdf
10-06
计算机试题试卷课件
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值