【链表】复杂链表的复制

问题描述

请实现函数ComplexListNode* Clone(ComplexListNode* pHead)，复制一个复杂链表。

在复杂链表中，每个结点除了有一个next指针指向下一个结点之外，还有一个random指向链表中的任意结点或者NULL。

结点的定义如下

struct RandomListNode {
int label;
struct RandomListNode *next, *random;
RandomListNode(int x) :
label(x), next(NULL), random(NULL) {
}
};

分析问题

方法1：

看到这个问题最直观的感受就是，把复制过程分为两步

(1)复制原始链表的每一个节点，并用next指针域连接起来

(2)设置每个节点的random 域；

假设原始链表中某个结点N的random 指针指向结点S,那么就需要从头到尾遍历查找结点S，如果从原始链表的头指针开始，经过m步之后达到结点S，那么在复制链表中的结点N’的random 指针指向的结点也是距离复制链表s步的结点。通过这种办法就可以为复制链表上的每个结点设置random 指针。

时间复杂度：定位每个节点的random域都需要从链表的头节点开始经过O(n)步才能找到，因此这种方法的时间复杂度O(N^2)。

方法2：

方法1的浪费的时间在查找每个节点random域，所以可以考虑把查找方面优化，利用哈希，空间换区时间，查找效率O(1)。

复制原始链表上的每个结点N创建N’，然后把这些创建出来的结点用pNext连接起来。同时把(N,N’)的配对信息方法一个哈希表中；然后设置复制链表中的每个结点的random指针，如果原始链表中结点N的random指向结点S，那么在复制链表中，对应的N’应该指向S’。

时间复杂度：O(N)。

方法3

在不借助辅助空间的下实现O(n)的时间效率。

第一步：根据原始链表的每个结点N创建对应的N’，然后将N‘通过pNext接到N的后面；CloneNodes函数实现

第二步：设置复制出来的结点的random。假设原始链表上的N的random指向结点S，那么其对应复制出来的N’是N->pNext指向的结点，同样S’也是结点S->pNext指向的结点。SetRadom函数实现

第三步：把长链表拆分成两个链表，把奇数位置的结点用pNext连接起来的就是原始链表，把偶数位置的结点通过pNext连接起来的就是复制链表。ReconnectList函数实现。

代码实现

1、hash 实现(方法2)

struct ComplexListNode{
int val;
ComplexListNode* pNext;
ComplexListNode* pSibling;
ComplexListNode():val(0),pNext(NULL),pSibling(NULL){};
};
typedef std::map<ComplexListNode*,ComplexListNode*> MAP;

ComplexListNode* CloneNodes(ComplexListNode* pHead,MAP &hashNode){
ComplexListNode* pNode=new ComplexListNode();
ComplexListNode* p=pNode;
ComplexListNode* tmp;

while(pHead!=NULL){
tmp=new ComplexListNode();
tmp->val=pHead->val;
p->pNext=tmp;
hashNode[pHead]=tmp;
pHead=pHead->pNext;
p=p->pNext;
}
return pNode->pNext;
}

void SetSiblings(ComplexListNode* pHead,ComplexListNode* pCopy,MAP &hashNode){
while(pCopy!=NULL){
pCopy->pSibling=hashNode[pHead->pSibling];
pCopy=pCopy->pNext;
pHead=pHead->pNext;
}
}

ComplexListNode* ComplexListCopy(ComplexListNode* pHead){
ComplexListNode* pCopy;
MAP hashNode;
pCopy=CloneNodes(pHead,hashNode);
SetSiblings(pHead,pCopy,hashNode);
return pCopy;
}

2、方法3的实现

void CloneNodes(RandomListNode* pHead)
{
RandomListNode* pCur = pHead;
while (pCur != NULL)
{
RandomListNode* pNewNode = new RandomListNode(pCur->label);
pNewNode->next = pCur->next;

pCur->next = pNewNode;
pCur = pNewNode->next;
}
}
//复制random指针域
void SetRadom(RandomListNode* pHead)
{
RandomListNode* pCur = pHead;
while (pCur != NULL)
{
RandomListNode* pCloneNode = pCur->next;
if (pCur->random != NULL)
{
pCloneNode->random = pCur->random->next;
}
pCur = pCloneNode->next;
}
}
//拆分成两个链表：奇数位 ，偶数位
RandomListNode* ReconnectList(RandomListNode* pHead)//头结点不为空
{
RandomListNode *pNode = pHead;
RandomListNode *pCloneHead = NULL;
RandomListNode *pCloneNode = NULL;

if (pNode != NULL)
{
pCloneHead = pCloneNode = pNode->next;
pNode->next = pCloneHead->next;
pNode = pNode->next;
}
while (pNode != NULL)
{
pCloneNode->next = pNode->next;
pCloneNode = pCloneNode->next;

pNode->next = pCloneNode->next;
pNode = pNode->next;
}
return pCloneHead;
}

RandomListNode* Clone(RandomListNode* pHead)
{
if (pHead == NULL)
return NULL;
CloneNodes(pHead);
SetRadom(pHead);
return ReconnectList(pHead);
}