【链表】复杂链表的复制

问题描述

请实现函数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);
}