复杂链表的复制

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

以下图为5个结点的复杂链表，实线表示m_pNext指针的指向，虚线表示m_pSibling指针的指向



方法一：

分两步

1：遍历一遍链表，用m_pNext指针将链表连起来，O(n)

2：确定每个m_pSibling指针的指向，需重新遍历新链表确定其m_pSibling的指向，O(n)

时间代价为O(n^2)，空间代价为0

方法二：

针对方法1中每次确定一个结点的m_pSibling指向效率较低，利用空间换取时间,同样分两步

1：遍历一遍链表，用m_pNext指针将链表连起来的同时，将原链表中的结点N和相应复制结点N'建立哈希映射<N,N'>

2：再次遍历一遍原链表，对于每一结点m通过哈希找到m'，并在原链表中找到m的m_pSibling所指向结点，再次通过哈希查找找到m'的m_pSibling指针应指向的结点，并修改m'的m_pSibling指针

时间代价为O(n)， 空间代价为O(n)

方法三：

比较巧妙，只需遍历3次链表，时间代价为O(n)，空间代价为0，分3步

1：遍历一遍原始链表，复制结点N对应的N'，将其插入到结点N的后面，如下图所示



代码如下：

void CloneNodes(ComplexListNode* pHead)
{
	ComplexListNode* p = pHead;
	while ( p )
	{
		ComplexListNode* pCloned = new ComplexListNode;
		pCloned->m_nValue = p->m_nValue;
		pCloned->m_pNext = p->m_pNext;
		p->m_pNext = pCloned;
		pCloned->m_pSibling = NULL;

		p = p->m_pNext;
	}
}

2：确定每个m_pSibling指针的指向，只需遍历一遍链表即可确定每个结点的m_pSibling指针的指向，得到如下图结构



代码如下：

void ConnectSiblingNodes(ComplexListNode* pHead)
{
	ComplexListNode* p = pHead;
	ComplexListNode* pCloned = NULL; //记录当前要确定其m_pSibling的结点

	while ( p )
	{
		pCloned = p->m_pNext;
		
		if ( pCloned->m_pSibling )
			pCloned->m_pSibling = p->m_pSibling->m_pNext;

		p = pCloned->m_pNext;
	}
}

3：再次遍历一遍，将原始链表和复制链表分开，奇数为原始链表，偶数为复制链表，得到如下图型



代码如下：

ComplexListNode* ReconnentNodes(ComplexListNode* pHead)
{
	ComplexListNode* pNode = pHead;
	ComplexListNode* pClonedHead = NULL;	//确定返回的头结点
	ComplexListNode* pClonedNode = NULL;

	//头结点特殊处理，边界条件判断
	if ( pNode != NULL )
	{
		pClonedHead = pNode->m_pNext;
		pClonedNode = pNode->m_pNext;

		pNode->m_pNext = pClonedHead->m_pNext;
		pNode = pNode->m_pNext;
	}

	while ( pNode )
	{
		pClonedNode->m_pNext = pNode->m_pNext;

		pNode->m_pNext = pClonedNode->m_pNext;

		pClonedNode = pClonedNode->m_pNext;
		
		pNode = pNode->m_pNext;
	}

	return pClonedHead;
}

最终将上述3步合并，就是复制复杂链表的全过程：

ComplexListNode* Clone(ComplexListNode* pHead)
{
	CloneNodes(pHead);
	ConnectSiblingNodes(pHead);
	
	return ReconnentNodes(pHead);
}