剑指offer---复杂链表的复制

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        
    }
};

class Solution {
    /**
     * 主要思路：
     * 原链表为 A->B->C
     * 将每个节点node克隆为node‘,同时将克隆节点和原节点穿插一起
     * 组成链表： A->A‘->B->B‘->C->C‘
     * 然后将继续复制random指针，next指针在节点穿插的时候已经完成
     * 最后将完整（所有指针都已经维护完毕）的链表A->A‘->B->B‘->C->C‘拆分为
     * A->B->C 和 A‘->B‘->C‘
     */
public:
    RandomListNode* Clone(RandomListNode* pHead) {
        if(pHead == NULL)
            return NULL;

        CloneNode(pHead);
        ConnectSlibingNode(pHead);
        return ReconnectNode(pHead);
    }
private:
    // 将所有节点克隆，并交叉连接（不包括random指针）
    void CloneNode(RandomListNode* pHead){
        RandomListNode* p = pHead;
        while(p != NULL){
            RandomListNode* pClone = new RandomListNode(p->label);
            pClone->next = p->next;
            p->next = pClone;
            p = pClone->next;
        }
    }
    // 连接克隆节点的random指针
    void ConnectSlibingNode(RandomListNode* pHead){
        RandomListNode* p = pHead;
        RandomListNode* pClone = p->next;
        while(p != NULL){
            if(p->random != NULL)
                pClone->random = p->random->next;
            p = pClone->next;
            pClone = p->next;
        }
    }
    //将含有原节点和克隆节点的链表拆分为原链表和由克隆节点组成的链表
    RandomListNode* ReconnectNode(RandomListNode* pHead){
        RandomListNode* p = pHead;
        RandomListNode* pClone = p->next;
        RandomListNode* pCloneHead = pClone;
        while(p->next != NULL){
            p->next = pClone->next;
            if(pClone->next != NULL){
                p = p->next;
                pClone->next = p->next;
                pClone = pClone->next;
            }
        }
        return pCloneHead;
    }
};