剑指offer（面试题35）：复杂链表的复制

/*
* 复杂链表的复制 
* 复杂链表是指，结点的指针可能不规则地指向另一个结点 
*/
#include<iostream>
using namespace std;

struct ComplexListNode {
    int value;
    ComplexListNode* next;
    ComplexListNode* pSibling;
    ComplexListNode():next(NULL),pSibling(NULL) {

    }
}; 

// 向后复制结点 
void CloneNodes(ComplexListNode* pNode);
// 复制sibling结点 
void ConnectSiblingNodes(ComplexListNode* pNode);
// 重新连接，分离原链表和复制后的链表 
ComplexListNode* ReconnectNodes(ComplexListNode* pNode);
// 主函数 
ComplexListNode* clone(ComplexListNode* pHead);

void CloneNodes(ComplexListNode* pRoot) {
    if(pRoot == NULL)
        return;

    ComplexListNode* pNode = pRoot;

    while(pNode != NULL) {
        cout << pNode->value << "->";
        ComplexListNode* pNew = new ComplexListNode();
        pNew->value = pNode->value;
        ComplexListNode* tmp = pNode->next;
        pNew->next = tmp;
        pNew->pSibling = NULL;

        pNode->next = pNew;
        pNode = pNew->next;
    }
}

// coped后的结点的 pSibling都为NULL，若检测到pSibling非NULL的结点
// 一定是原链表上的结点，因此下一个结点一定的复制的结点 
void ConnectSiblingNodes(ComplexListNode* pRoot) {
    if(pRoot == NULL) return;

    ComplexListNode* pNode = pRoot;
    while(pNode != NULL) {
        ComplexListNode* pClone = pNode->next;
        if(pNode->pSibling != NULL) {
//          cout << pNode->pSibling->value << endl;
            ComplexListNode* tmp = pNode->pSibling; 
            pClone->pSibling = tmp->next;
        }
        pNode = pClone->next;
    }
}

//根据原结点在前，复制的结点在后
// 将链表分成两段一样的链表，如此便得到复杂链表的复制 
ComplexListNode* ReconnectNodes(ComplexListNode* pRoot) {
    if(pRoot == NULL)
        return NULL;

    int index = 1;
    ComplexListNode* pNode = pRoot;
    ComplexListNode* pCloneHead = NULL;
    ComplexListNode* pCloneNode = NULL;
     while(pNode != NULL) {
        if(index % 2 == 0) {
            if(pCloneHead == NULL) {
                pCloneHead = pNode;
                pCloneNode = pCloneHead;
            } else {
                pCloneNode->next = pNode;
                pCloneNode = pCloneNode->next;  
            }
         }
         pNode = pNode->next;
         index ++;
     }
//  ComplexListNode* pNode1 = pCloneHead;
//  cout << "cloned" << endl;
//  while(pNode1) {
//      cout << pNode1->value << "->";
//      if(pNode1->pSibling)
//          cout << "(s->" << pNode1->pSibling->value << ")->";
//      pNode1 = pNode1->next; 
//  }
    return pCloneHead;
}

ComplexListNode* clone(ComplexListNode* pHead) {
    CloneNodes(pHead);
    ComplexListNode* pNode = pHead;
    ConnectSiblingNodes(pHead);
//  pNode = pHead;
//  cout << "connected" << endl;
//  while(pNode) {
//      cout << pNode->value << "->";
//      pNode= pNode->next; 
//  }
    return ReconnectNodes(pHead);    
}

int main() {
    ComplexListNode* pHead = new ComplexListNode();
    ComplexListNode* p1 = new ComplexListNode();
    ComplexListNode* p2 = new ComplexListNode();
    pHead->value = 1;
    p1->value = 2;
    p2->value = 3;
    pHead->next = p1;
    p1->next = p2;
    pHead->pSibling = p2;
    p2->pSibling = pHead;


    ComplexListNode* res = clone(pHead);


}