【剑指Offer】复杂链表的复制

1.题目

2.解法：

（1）直接复制：先处理普通指针，再处理随机指针

时间复杂度：O(n^2)，额外空间复杂度：O(1)

因为在确定clone链表的每个节点的random指针的时候都需要从头去遍历原链表

Code

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x):label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead){
        if(pHead == NULL)    return NULL;
        
        //复制普通的链表指针部分
        RandomListNode* pCloneHead = new RandomListNode(pHead->label);
        RandomListNode* pClone = pCloneHead;
        RandomListNode* pNode = pHead->next;
        RandomListNode* pTmp = NULL;
        while(pNode){
            pTmp = new RandomListNode(pNode->label);
            pClone->next = pTmp;
            pClone = pClone->next;
            pNode = pNode->next;
        }
        
        //复制random指针部分
        pNode = pHead;
        pClone = pCloneHead;
        int step;
        while(pNode){
            //原链表该节点的random指针有指向
            if(pNode->random != NULL){
                step = 0;
                pTmp = pHead;
                while(pTmp != pNode->random){
                    step++;
                    pTmp = pTmp->next;
                }
                pTmp = pCloneHead;
                for(int i = 0; i < step; ++i){
                    pTmp = pTmp->next;
                }
                pClone->random = pTmp;
            }
            pNode = pNode->next;
            pClone = pClone->next;
        }
       return pCloneHead;
    }
};

（2）哈希表：存储原链表节点和Clone链表对应节点的关系（以空间换时间）

时间复杂度 ：O(n) ，额外空间复杂度：O(n)

Code

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) : label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead){
        if(pHead == NULL)    return NULL;
        map<RandomListNode*,RandomListNode*> mp;
        RandomListNode* pCloneHead = new RandomListNode(pHead->label);
        RandomListNode* pClone = pCloneHead;
        mp[pHead] = pCloneHead;
        RandomListNode* pNode = pHead->next;
        RandomListNode* pTmp = NULL;
        
        //处理普通指针    
        while(pNode){
            pTmp = new RandomListNode(pNode->label);
            pClone->next = pTmp;
            mp[pNode] = pTmp;
            pNode = pNode->next;
            pClone = pClone->next;
        }
        
        //处理random指针
        pNode = pHead;
        while(pNode){
            if(pNode->random){
                mp[pNode]->random = mp[pNode->random];
            }
            pNode = pNode->next;
        }
        return pCloneHead;
    }
};

（3）来自剑指offer的巧妙解法（不得不说tql）

没有借助额外的空间，就做到了时间复杂度降到O(n)

将要该节点要复制出来的节点x就链接到该节点的后面，这样x节点的random指针的指向就是该节点指向节点的next(看图所示)…最后再根据奇偶性将链表拆分即可。

Code

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    //step1：生成新节点链接到原节点后面
    void CloneNewNode_Connect(RandomListNode* pHead)
    {
        RandomListNode* pNode = pHead;
        RandomListNode* pTmp = NULL;

        while(pNode){
            pTmp = new RandomListNode(pNode->label);
            pTmp->next = pNode->next;
            pTmp->random = NULL;
            pNode->next = pTmp;
            pNode = pTmp->next;
        }
    }

    //step2：处理random指针
    void DealRandom(RandomListNode* pHead)
    {
        RandomListNode* pNode = pHead;
        while(pNode){
            if(pNode->random){
                pNode->next->random = pNode->random->next;
            }
            pNode = pNode->next->next;  //跳到原链表的下一个节点
        }

    }
    
    //step3：拆分链表，返回Clone链表
    RandomListNode* Breakup(RandomListNode* pHead)
    {
        RandomListNode* pNode = pHead;
        RandomListNode* pCloneHead = NULL;
        RandomListNode* pClone = NULL;
        
        pClone = pCloneHead = pNode->next;
        pNode->next = pClone->next;
        pNode = pNode->next;
        while(pNode){
            pClone->next = pNode->next;
            pClone = pClone->next;
            pNode->next = pClone->next;
            pNode = pNode->next;
        }
        return pCloneHead;
    }


    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(pHead == NULL)   return NULL;
        
        CloneNewNode_Connect(pHead);
        DealRandom(pHead);
        return Breakup(pHead);
    }
};