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

题目：有一个复杂链表，其结点除了有一个m_pNext指针指向下一个结点外，还有一个m_pSibling指向链表中的任一结点或者NULL。其结点的C++定义如下：

 struct ComplexNode

{

    int m_nValue;

    ComplexNode* m_pNext;

    ComplexNode* m_pSibling;

};

（1）复制每一个结点N为N*，不同的是我们将N*让在对应的N后面，即为

（2）确定每一个N*的sibling分量，非常明显，N的sibling分量的next就是N*的sibling分量。

（3）将整个链表拆分成原始链表和拷贝出的链表。

#include<iostream>
using namespace std;

struct ComplexListNode
{
    int                 m_nValue;
    ComplexListNode*    m_pNext;
    ComplexListNode*    m_pSibling;
};

ComplexListNode* CreateNode(int nValue)
{
	ComplexListNode* pNode = new ComplexListNode();    
    pNode->m_nValue = nValue;
    pNode->m_pNext = NULL;
    pNode->m_pSibling = NULL;
    return pNode;
}
void BuildNodes(ComplexListNode* pNode, ComplexListNode* pNext, ComplexListNode* pSibling)
{
	if(pNode!=NULL)
	{
		  pNode->m_pNext = pNext;
		  pNode->m_pSibling = pSibling;
	}
}
void PrintList(ComplexListNode* pHead)
{
	ComplexListNode* pNode = pHead;
    while(pNode != NULL)
    {
        cout<<"The value of this node is: "<<pNode->m_nValue<<endl;

        if(pNode->m_pSibling != NULL)
            cout<<"The value of its sibling is: "<<pNode->m_pSibling->m_nValue<<endl;
        else
             cout<<"This node does not have a sibling.\n";

       cout<<endl;
       pNode = pNode->m_pNext;
    }
}
void CloneNodes(ComplexListNode* pHead)
{
	ComplexListNode* p = pHead;
	while(p!=NULL)
	{
         ComplexListNode* cloned = new ComplexListNode();
		 cloned->m_nValue = p->m_nValue;
		 cloned->m_pNext = p->m_pNext;
		 cloned->m_pSibling = NULL;

		 p->m_pNext = cloned;
		 p = cloned->m_pNext;
	}	
}
void ConnectSiblingNodes(ComplexListNode* pHead)
{
	ComplexListNode* p = pHead;
	while(p!=NULL)
	{		
		ComplexListNode* cloned = p->m_pNext;
		if(p->m_pSibling!=NULL)		
		{		
			cloned->m_pSibling = p->m_pSibling->m_pNext;
		}
		p=cloned->m_pNext;
	}		
}
ComplexListNode* ReconnectNodes(ComplexListNode* pHead)
{
	 ComplexListNode* pNode = pHead;
	 ComplexListNode* pClonedHead = NULL;
	 ComplexListNode* pClonedNode = NULL;

	 if(pNode!=NULL)
	 {
		  pClonedNode = pClonedHead = pNode->m_pNext;		
		 pNode->m_pNext = pClonedNode->m_pNext;     
		 pNode = pClonedNode->m_pNext;

		 while(pNode!=NULL)
		 {
			  pClonedNode->m_pNext = pNode->m_pNext;
			 pClonedNode = pClonedNode->m_pNext;
			 pNode->m_pNext = pClonedNode->m_pNext;
			 pNode =  pClonedNode->m_pNext;			
		 }
	}
	 return pClonedHead ;
}
 ComplexListNode* Clone(ComplexListNode* pHead)
 {
	CloneNodes(pHead);
    ConnectSiblingNodes(pHead);
    return ReconnectNodes(pHead);
 }

// ====================测试代码====================
void Test(char* testName, ComplexListNode* pHead)
{
    if(testName != NULL)
        printf("%s begins:\n", testName);

    printf("The original list is:\n");
    PrintList(pHead);		
	

    ComplexListNode* pClonedHead = Clone(pHead);

    printf("The cloned list is:\n");
    PrintList(pClonedHead);
}

//          -----------------
//         \|/              |
//  1-------2-------3-------4-------5
//  |       |      /|\             /|\
//  --------+--------               |
//          -------------------------
void Test1()
{
    ComplexListNode* pNode1 = CreateNode(1);
    ComplexListNode* pNode2 = CreateNode(2);
    ComplexListNode* pNode3 = CreateNode(3);
    ComplexListNode* pNode4 = CreateNode(4);
    ComplexListNode* pNode5 = CreateNode(5);

    BuildNodes(pNode1, pNode2, pNode3);
    BuildNodes(pNode2, pNode3, pNode5);
    BuildNodes(pNode3, pNode4, NULL);
    BuildNodes(pNode4, pNode5, pNode2);

    Test("Test1", pNode1);
}

// m_pSibling指向结点自身
//          ------------
//         \|/              |
//  1-------2-------3-------4-------5
//         |       | /|\           /|\
//         |       | --             |
//         |------------------------|
void Test2()
{
    ComplexListNode* pNode1 = CreateNode(1);
    ComplexListNode* pNode2 = CreateNode(2);
    ComplexListNode* pNode3 = CreateNode(3);
    ComplexListNode* pNode4 = CreateNode(4);
    ComplexListNode* pNode5 = CreateNode(5);

    BuildNodes(pNode1, pNode2, NULL);
    BuildNodes(pNode2, pNode3, pNode5);
    BuildNodes(pNode3, pNode4, pNode3);
    BuildNodes(pNode4, pNode5, pNode2);

    Test("Test2", pNode1);
}

// m_pSibling形成环
//          ------------
//         \|/              |
//  1-------2-------3-------4-------5
//          |              /|\
//          |               |
//          |---------------|
void Test3()
{
    ComplexListNode* pNode1 = CreateNode(1);
    ComplexListNode* pNode2 = CreateNode(2);
    ComplexListNode* pNode3 = CreateNode(3);
    ComplexListNode* pNode4 = CreateNode(4);
    ComplexListNode* pNode5 = CreateNode(5);

    BuildNodes(pNode1, pNode2, NULL);
    BuildNodes(pNode2, pNode3, pNode4);
    BuildNodes(pNode3, pNode4, NULL);
    BuildNodes(pNode4, pNode5, pNode2);

    Test("Test3", pNode1);
}

// 只有一个结点
void Test4()
{
    ComplexListNode* pNode1 = CreateNode(1);
    BuildNodes(pNode1, NULL, pNode1);

    Test("Test4", pNode1);
}

// 鲁棒性测试
void Test5()
{
    Test("Test5", NULL);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();

    return 0;
}