剑指Offer----面试题26：复杂链表的复制

最新推荐文章于 2021-05-18 18:30:19 发布
最新推荐文章于 2021-05-18 18:30:19 发布
阅读量405 收藏 1
点赞数
分类专栏： 剑指Offer 文章标签： C++ 剑指offer 面试题 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qianqin_2014/article/details/51596138
版权

题目：

请实现哈数ComplexListNode *Clone(ComplexListNode *pHead)，复制一个复杂链表。在复杂链表中，每个结点除了有一个next指针指向下一个结点外，还有一个sibling指向链表的任意结点或者NULL。


分析：


如下图是一个含有5个结点的复杂链表，实箭头代表next指针，虚箭头代表sibling指针。指向NULL的指针没有画出。


第一步：根据原始链表的每个结点N创建对应的N‘，并把N’链接在N的后面。经过这一步，链表的形式如下图所示：


代码如下： 
void CloneNode(ComplexListNode *pHead)
{
	ComplexListNode *node = pHead;
	
	while (node != NULL)
	{
		ComplexListNode *copy = new ComplexListNode();
		copy->element = node->element;
		copy->next = node->next;

		node->next = copy;
		node = copy->next;
	}
}

第二步：设置复制出来结点的sibling，假设原始链表上N的sibling指向结点S，那么其对应复制出来的N‘是N的next指向的结点，同样S’也是S的next指向的结点。经过这一步，链表的形式如下图所示：

代码如下： 
void ConnectSibling(ComplexListNode *pHead)
{
	ComplexListNode *node = pHead;
	while (node != NULL)
	{
		ComplexListNode *copy = node->next;
		if (node->sibling != NULL)
			copy->sibling = node->sibling->next;
		else
			copy->sibling = NULL;
		node = copy->next;
	}
}

第三步：把这个长链表拆分成两个链表。把奇数位置的结点用next链接起来就是原始链表，把偶数为止的结点用next连接起来就是复制出来的链表。经过这一步，链表的形式如下图所示：

代码如下： 
ComplexListNode *ReConnectNodes(ComplexListNode *pHead)
{
	ComplexListNode *node = pHead;
	ComplexListNode *copyHead = NULL;
	ComplexListNode *copyNode = NULL;

	if (node != NULL)
	{
		copyHead = copyNode = node->next;//复制链表的头结点
		node->next = copyNode->next;
		node = node->next;
	}

	while (node != NULL)
	{
		copyNode->next = node->next;
		copyNode = copyNode->next;
		node->next = copyHead->next;
		node = node->next;
	}

	return copyHead;
}

最后将上面上面三步合在一起即可： 

ComplexListNode *Clone(ComplexListNode *pHead)
{
	CloneNode(pHead);
	ConnectSibling(pHead);
	return ReConnectNodes(pHead);
}

官方源代码(有改动)：


头文件ComplexListNode.h 
#ifndef COMPLEXLISTNODE_H
#define COMPLEXLISTNODE_H

namespace ComplexListNodeSpace
{
	struct ComplexListNode
	{
		int element;
		ComplexListNode *next;
		ComplexListNode *sibling;
	};

	ComplexListNode *CreateComplexListNode(int value);
	void ConnectComplexListNode(ComplexListNode *root, ComplexListNode *pNext, ComplexListNode *pSibling);
	void printComplexList(ComplexListNode *root);
	void DestoryComplexList(ComplexListNode *root);
}

#endif

复杂链表实现文件ComplexListNode.cpp 
#include"ComplexListNode.h"
#include<iostream>

using std::cout;
using std::endl;

namespace ComplexListNodeSpace
{

	ComplexListNode *CreateComplexListNode(int value)
	{
		ComplexListNode *temp = new ComplexListNode();
		temp->element = value;
		temp->next = NULL;
		temp->sibling = NULL;

		return temp;
	}

	void ConnectComplexListNode(ComplexListNode *root, ComplexListNode *pNext, ComplexListNode *pSibling)
	{
		if (root == NULL)
			return;

		root->next = pNext;
		root->sibling = pSibling;
	}

	void printComplexList(ComplexListNode *root)
	{
		if (root == NULL)
		{
			cout << "The tree is empty" << endl;
			return;
		}

		ComplexListNode *temp = root;
		while (temp != NULL)
		{
			cout << "The value of this node is " << temp->element << endl;
			if (temp->sibling != NULL)
				cout << "The sibling value of this node is " << temp->sibling->element << endl;
			else
				cout << "The sibling of this node is NULL" << endl;

			temp = temp->next;
		}
	}

	void DestoryComplexList(ComplexListNode *root)
	{
		if (root == NULL)
			return;

		ComplexListNode *temp = root;
		while (temp != NULL)
		{
			root = root->next;
			delete temp;
			temp = root;
		}

		root = NULL;
	}
}

测试文件: 
#include"ComplexListNode.h"
#include<cstdlib>
#include<cstdio>

using namespace ComplexListNodeSpace;

void CloneNodes(ComplexListNode* pHead);
void ConnectSiblingNodes(ComplexListNode* pHead);
ComplexListNode* ReconnectNodes(ComplexListNode* pHead);

ComplexListNode* Clone(ComplexListNode* pHead)
{
	CloneNodes(pHead);
	ConnectSiblingNodes(pHead);
	return ReconnectNodes(pHead);
}

void CloneNodes(ComplexListNode* pHead)
{
	ComplexListNode* pNode = pHead;
	while (pNode != NULL)
	{
		ComplexListNode* pCloned = new ComplexListNode();
		pCloned->element = pNode->element;
		pCloned->next = pNode->next;
		pCloned->sibling = NULL;

		pNode->next = pCloned;

		pNode = pCloned->next;
	}
}

void ConnectSiblingNodes(ComplexListNode* pHead)
{
	ComplexListNode* pNode = pHead;
	while (pNode != NULL)
	{
		ComplexListNode* pCloned = pNode->next;
		if (pNode->sibling != NULL)
		{
			pCloned->sibling = pNode->sibling->next;
		}

		pNode = pCloned->next;
	}
}

ComplexListNode* ReconnectNodes(ComplexListNode* pHead)
{
	ComplexListNode* pNode = pHead;
	ComplexListNode* pClonedHead = NULL;
	ComplexListNode* pClonedNode = NULL;

	if (pNode != NULL)
	{
		pClonedHead = pClonedNode = pNode->next;
		pNode->next = pClonedNode->next;
		pNode = pNode->next;
	}

	while (pNode != NULL)
	{
		pClonedNode->next = pNode->next;
		pClonedNode = pClonedNode->next;

		pNode->next = pClonedNode->next;
		pNode = pNode->next;
	}

	return pClonedHead;
}

// ====================测试代码====================
void Test(char* testName, ComplexListNode* pHead)
{
	if (testName != NULL)
		printf("%s begins:\n", testName);

	printf("The original list is:\n");
	printComplexList(pHead);

	ComplexListNode* pClonedHead = Clone(pHead);

	printf("======The cloned list is:\n");
	printComplexList(pClonedHead);
}

//          -----------------
//         \|/              |
//  1-------2-------3-------4-------5
//  |       |      /|\             /|\
//  --------+--------               |
//          -------------------------
void Test1()
{
	printf("\t==============test1：普通==============\n");
	ComplexListNode* pNode1 = CreateComplexListNode(1);
	ComplexListNode* pNode2 = CreateComplexListNode(2);
	ComplexListNode* pNode3 = CreateComplexListNode(3);
	ComplexListNode* pNode4 = CreateComplexListNode(4);
	ComplexListNode* pNode5 = CreateComplexListNode(5);

	ConnectComplexListNode(pNode1, pNode2, pNode3);
	ConnectComplexListNode(pNode2, pNode3, pNode5);
	ConnectComplexListNode(pNode3, pNode4, NULL);
	ConnectComplexListNode(pNode4, pNode5, pNode2);

	Test("Test1", pNode1);

	DestoryComplexList(pNode1);
}

// m_pSibling指向结点自身
//          -----------------
//         \|/              |
//  1-------2-------3-------4-------5
//         |       | /|\           /|\
//         |       | --             |
//         |------------------------|
void Test2()
{
	printf("\t==============test2：sibliing指向结点自身==============\n");
	ComplexListNode* pNode1 = CreateComplexListNode(1);
	ComplexListNode* pNode2 = CreateComplexListNode(2);
	ComplexListNode* pNode3 = CreateComplexListNode(3);
	ComplexListNode* pNode4 = CreateComplexListNode(4);
	ComplexListNode* pNode5 = CreateComplexListNode(5);

	ConnectComplexListNode(pNode1, pNode2, NULL);
	ConnectComplexListNode(pNode2, pNode3, pNode5);
	ConnectComplexListNode(pNode3, pNode4, pNode3);
	ConnectComplexListNode(pNode4, pNode5, pNode2);

	Test("Test2", pNode1);
	DestoryComplexList(pNode1);
}

// m_pSibling形成环
//          -----------------
//         \|/              |
//  1-------2-------3-------4-------5
//          |              /|\
//          |               |
//          |---------------|
void Test3()
{
	printf("\t==============test3：sibling形成环==============\n");
	ComplexListNode* pNode1 = CreateComplexListNode(1);
	ComplexListNode* pNode2 = CreateComplexListNode(2);
	ComplexListNode* pNode3 = CreateComplexListNode(3);
	ComplexListNode* pNode4 = CreateComplexListNode(4);
	ComplexListNode* pNode5 = CreateComplexListNode(5);

	ConnectComplexListNode(pNode1, pNode2, NULL);
	ConnectComplexListNode(pNode2, pNode3, pNode4);
	ConnectComplexListNode(pNode3, pNode4, NULL);
	ConnectComplexListNode(pNode4, pNode5, pNode2);

	Test("Test3", pNode1);
	DestoryComplexList(pNode1);
}

// 只有一个结点
void Test4()
{
	printf("\t==============test4：只有一个结点==============\n");
	ComplexListNode* pNode1 = CreateComplexListNode(1);
	ConnectComplexListNode(pNode1, NULL, pNode1);

	Test("Test4", pNode1);
	DestoryComplexList(pNode1);
}

// 鲁棒性测试
void Test5()
{
	printf("\t==============test5:空链表==============\n");
	Test("Test5", NULL);
}

int main()
{
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();

	system("pause");
	return 0;
}

运行结果： 
        ==============test1：普通==============
Test1 begins:
The original list is:
The value of this node is 1
The sibling value of this node is 3
The value of this node is 2
The sibling value of this node is 5
The value of this node is 3
The sibling of this node is NULL
The value of this node is 4
The sibling value of this node is 2
The value of this node is 5
The sibling of this node is NULL
======The cloned list is:
The value of this node is 1
The sibling value of this node is 3
The value of this node is 2
The sibling value of this node is 5
The value of this node is 3
The sibling of this node is NULL
The value of this node is 4
The sibling value of this node is 2
The value of this node is 5
The sibling of this node is NULL
        ==============test2：sibliing指向结点自身==============
Test2 begins:
The original list is:
The value of this node is 1
The sibling of this node is NULL
The value of this node is 2
The sibling value of this node is 5
The value of this node is 3
The sibling value of this node is 3
The value of this node is 4
The sibling value of this node is 2
The value of this node is 5
The sibling of this node is NULL
======The cloned list is:
The value of this node is 1
The sibling of this node is NULL
The value of this node is 2
The sibling value of this node is 5
The value of this node is 3
The sibling value of this node is 3
The value of this node is 4
The sibling value of this node is 2
The value of this node is 5
The sibling of this node is NULL
        ==============test3：sibling形成环==============
Test3 begins:
The original list is:
The value of this node is 1
The sibling of this node is NULL
The value of this node is 2
The sibling value of this node is 4
The value of this node is 3
The sibling of this node is NULL
The value of this node is 4
The sibling value of this node is 2
The value of this node is 5
The sibling of this node is NULL
======The cloned list is:
The value of this node is 1
The sibling of this node is NULL
The value of this node is 2
The sibling value of this node is 4
The value of this node is 3
The sibling of this node is NULL
The value of this node is 4
The sibling value of this node is 2
The value of this node is 5
The sibling of this node is NULL
        ==============test4：只有一个结点==============
Test4 begins:
The original list is:
The value of this node is 1
The sibling value of this node is 1
======The cloned list is:
The value of this node is 1
The sibling value of this node is 1
        ==============test5:空链表==============
Test5 begins:
The original list is:
The tree is empty
======The cloned list is:
The tree is empty
请按任意键继续. . .



普通链表的复制：

#include"List.h"
#include<iostream>


using std::cout;
using std::endl;

using  namespace ListSpace4;

ListNode *CopyList(ListNode *root)
{
	if (root == nullptr)
	{
		cout << "链表为空，无法复制" << endl;
		return nullptr;
	}

	ListNode *prev = nullptr;
	ListNode *node = nullptr;
	ListNode *head = nullptr;
	int count = 0;

	while (root != nullptr)
	{
		node = CreateListNode(root->element);
		++count;
		if (count == 1)
		{
			head = node;
		}
		else
		{
			prev->next = node;
		}
		prev = node;
		node->next = nullptr;
		root = root->next;
	}

	return head;
}

void test41()
{
	cout << "\t==========测试非空链表的复制==========" << endl;
	ListNode *list1 = CreateListNode(1);
	ListNode *list2 = CreateListNode(2);
	ListNode *list3 = CreateListNode(3);
	ListNode *list4 = CreateListNode(4);
	ListNode *list5 = CreateListNode(5);
	ListNode *list6 = CreateListNode(6);

	ConnectListNodes(list1, list2);
	ConnectListNodes(list2, list3);
	ConnectListNodes(list3, list4);
	ConnectListNodes(list4, list5);
	ConnectListNodes(list5, list6);
	ConnectListNodes(list6, NULL);

	cout << "复制链表之前:";
	printList(list1);
	cout << endl;
	cout << "复制链表之后:";
	ListNode *copy = CopyList(list1);
	printList(copy);
	cout << endl;
	DestoryList(&list1);
	DestoryList(&copy);
}

void test42()
{
	cout << "\t==========测试只有一个结点的链表==========" << endl;
	ListNode *list1 = CreateListNode(1);

	ConnectListNodes(list1, NULL);


	cout << "复制之前表之前:";
	printList(list1);
	cout << endl;
	cout << "反转链表之后:";
	ListNode *copy = CopyList(list1);
	printList(copy);
	cout << endl;
	DestoryList(&list1);
	DestoryList(&copy);

	DestoryList(&list1);

}

void test43()
{
	cout << "\t==========测试只有空链表==========" << endl;
	cout << "复制之前表之前:";
	printList(nullptr);
	cout << endl;
	cout << "反转链表之后:";
	ListNode *copy = CopyList(nullptr);
	printList(copy);
	cout << endl;
}

int main()
{
	test41();
	cout << endl;

	test42();
	cout << endl;

	test43();
	cout << endl;

	system("pause");
	return 0;
}

运行结果： 
        ==========测试非空链表的复制==========
复制链表之前:1  2  3  4  5  6
复制链表之后:1  2  3  4  5  6

        ==========测试只有一个结点的链表==========
复制之前表之前:1
反转链表之后:1

        ==========测试只有空链表==========
复制之前表之前:The list is empty

反转链表之后:链表为空，无法复制
The list is empty


请按任意键继续. . .



烽火前秦路
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer面试题26:复杂链表的复制Java实现
jackyechina的专栏
10-25 915
题目描述： 一个复杂链表，在复杂链表中，每个结点除了有一个next指针指向下一个结点外，还有一个sbiling指向链表中的任意结点或者null。 下图是一个复杂链表的示例，Null的指针没有画出。  解题思路： 1.很直观的解法就是分成两步： 1).原始链表上的每一个结点，并用next指针连起来。         2).sbiling指针。     
剑指offer第二版（Python3）--面试题35：复杂链表的复制
鲁班七号
11-12 279
输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
剑指offer-面试题26-复杂链表的复制
但觉
01-19 285
题目描述：请实现函数ComplexListNode clone(ComplexListNode head),复制一个复杂链表。在复杂链表中，每个结点除了有一个next 域指向下一个结点外，还有一个sibling 指向链表中的任意结点或者null。题目解析： 如图结构。 第一步，根据原始链表的每一个结点N创建对应的N’，我们把N’接在N的后面。处理后如图 第二步，假如B指向E，那么B’指向E
剑指offer - 面试题35: 复杂链表的复制 - C++
L_bic的博客
03-03 365
二刷：好几次才过： 1.label写成val 2.最后一个函数赋值逻辑错误 3.random可能是nullptr，所以不能直接->random->next 4.同一刷的第二。最后只有一个nullptr，需要手动赋一个nullptr。 些许欣慰的是，一刷里的while-do do-while问题这次写的应该比较合理。 class Solution { public: ...
剑指Offer - 面试题24：反转链表
林夕07
05-18 185
题目 定义一个函数，输入一个链表的头就额点，反转该链表并疏忽从反转后链表的头节点。链表节点定义如下： typedef int TElemType;//链表节点值的数据类型 struct ListNode { TElemType Data; ListNode* Next; }; 分析 反转链表需要用到三个指针。later指针和node指针用于转方向，front指针用于记录下一个节点位置。 反转核心四步如下图 C++ #include <iostream> using name
剑指offer 面试题35：复杂链表的复制
Ben
08-14 162
此题中链表共有next和任意指向的next两种指针，重点在如何设置random指针 思路一：采用map，存储原链表和新复制链表之间的对应关系，然后设置random指针 /* struct RandomListNode { int label; struct RandomListNode *next, *random; RandomListNode(int x) : ...
剑指offer-4-面试26：复杂链表的复制
梦里水乡的专栏
07-12 788
题目 分析 测试用例代码 本题考点 题目 请实现函数 ComplexListNode* Clone( ComplexListNode* pHead )，复制一个复杂链表。在复杂链表中，每个结点除了有一个m_pNext指针指向下一个结点外，还有一个 m_pSibling指向链表中的任意结点或者NULL。结点的C++定义如下。struct ComplexListNode { int
剑指Offer-链表-面试题35:复杂链表的复制
linyuhan3232的博客
05-05 112
面试题35:复杂链表的复制 题目描述： 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空） 代码： /* struct RandomListNode { int label; struct RandomList...
剑指offer---复杂链表复制
fangfang_666的博客
07-13 747
剑指offer面试题---复杂链表复制 分析此题：1.首先要将链表的每一个节点复制一份，连在被复制节点后面。                    2.将对应的指向关系也对应复制。                    3.分离原链表、复制链表。 代码实现： struct ComplexListNode { int _data; ComplexListNode* _next;
华为研发工程师编程题(2)----明明的随机数
热门推荐
烽火前秦路
04-28 2万+
试题： 明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。 Input Param n 输入随机数的个数 inputArra
华为研发工程师编程题(1)----汽水瓶
烽火前秦路
04-28 6864
试题： 有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶. 方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
华为2016年校园招聘上机笔试题(3)----扑克牌大小
烽火前秦路
05-03 3836
扑克牌游戏大家应该都比较熟悉了，一副牌由54张组成，含3~A，2各4张，小王1张，大王1张。牌面从小到大用如下字符和字符串表示（其中，小写joker表示小王，大写JOKER表示大王）:) 3 4 5 6 7 8 9 10 J Q K A 2 joker JOKER 输入两手牌，两手牌之间用“-”连接，每手牌的每张牌以空格分隔，“-”两边没有空格，如：4 4 4 4-joker JOKER 请
结构体内存对齐问题
烽火前秦路
04-06 1982
转自 我们先看一道IBM和微软的笔试题： IBM笔试题： struct{ short a1; short a2; short a3; }A; struct{ long a1; short a2; }B; sizeof( A)=6, sizeof(B)=8,为什么？ 注：sizeof(short)=2,sizeof(lo
华为2016研发工程师编程题(1)----删数
烽火前秦路
05-03 1656
问题： 有一个数组a[N]顺序存放0-N，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。 以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。 输入描述: 每组数据为一行一个整数n(小于等于1000)，为数组成员数,如100，则对
剑指Offer----面试题二：实现Singleton模式
烽火前秦路
05-18 1569
题目：设计一个类，我们只能生成该类的一个实例。 详解请参考More Effective C++ 第26款：限制某个类所能产生的对象的数量 在这里我将给出三个实例： 实例一：一个类只能产生一个对象 #include #include //类的声明 namespace MyStrSpace{ class MyStr{ public: void print(){ std::co
剑指Offer----面试题九：斐波那契数列
烽火前秦路
06-02 1513
题目： 写一个函数，输入n，求斐波那契数列（Fibonacci）的第n项，斐波那契数列的定义如下： 方法一： 第一种方法就是我们在学习C或者C++语言时接触到的递归调用，程序源代码如下： #include #include #include #include using std::cin; using std::cout; using std::endl; using s
剑指Offer----面试题35：扩展----第一个字符串中删除第二个字符串中出现过的所有字符
烽火前秦路
08-01 1450
题目： 定义一个函数，输入两个字符串，从第一个字符串中删除在第二个字符串中出现过的所有字符。例如从第一个字符串"We are students"中删除第二个字符串“aeiou”中出现过的字符得到的结果就是“W r stdnts”。 分析： 为了解决这个问题，我们可以创建一个用数组实现的简单哈希表来存储第二个字符串。这样我们从头到尾扫描第一个字符串中的每一个字符时，用O
剑指Offer----扩展：小东分苹果（京东）
烽火前秦路
08-29 1410
问题描述： 果园里有一堆苹果，一共n头(n大于1小于9)熊来分，第一头为小东，它把苹果均分n份后，多出了一个，它扔掉了这一个，拿走了自己的一份苹果，接着第二头熊重复这一过程，即先均分n份，扔掉一个然后拿走一份，以此类推直到最后一头熊都是这样(最后一头熊扔掉后可以拿走0个，也算是n份均分)。问最初这堆苹果最少有多少个。 给定一个整数n,表示熊的个数，返回最初的苹果数。保证有解。
剑指Offer：信息技术面试题集锦
剑指Offer是一系列针对面试中常见的算法问题进行讲解和练习的编程题目集，这些题目主要覆盖了数据结构（如数组、链表、树）、算法基础（如排序、查找、递归、分治、动态规划）、字符串处理、位运算以及数学逻辑等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值