面试题26 复杂链表的复制

[cpp]  view plain copy print ?

1. struct ComplexListNode  
2. {  
3.     int m_nValue;  
4.     ComplexListNode* m_pNext;  
5.     ComplexListNode* m_pSibling;  
6. };  

以下图为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的后面，如下图所示

代码如下：

[cpp]  view plain copy print ?

1. void CloneNodes(ComplexListNode* pHead)  
2. {  
3.     ComplexListNode* p = pHead;  
4.     while ( p )  
5.     {  
6.         ComplexListNode* pCloned = new ComplexListNode;  
7.         pCloned->m_nValue = p->m_nValue;  
8.         pCloned->m_pNext = p->m_pNext;  
9.         p->m_pNext = pCloned;  
10.         pCloned->m_pSibling = NULL;  
11.   
12.         p = p->m_pNext;  
13.     }  
14. }  

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

代码如下：

[cpp]  view plain copy print ?

1. void ConnectSiblingNodes(ComplexListNode* pHead)  
2. {  
3.     ComplexListNode* p = pHead;  
4.     ComplexListNode* pCloned = NULL; //记录当前要确定其m_pSibling的结点  
5.   
6.     while ( p )  
7.     {  
8.         pCloned = p->m_pNext;  
9.           
10.         if ( pCloned->m_pSibling )  
11.             pCloned->m_pSibling = p->m_pSibling->m_pNext;  
12.   
13.         p = pCloned->m_pNext;  
14.     }  
15. }  

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

代码如下：

[cpp]  view plain copy print ?

1. ComplexListNode* ReconnentNodes(ComplexListNode* pHead)  
2. {  
3.     ComplexListNode* pNode = pHead;  
4.     ComplexListNode* pClonedHead = NULL;    //确定返回的头结点  
5.     ComplexListNode* pClonedNode = NULL;  
6.   
7.     //头结点特殊处理，边界条件判断  
8.     if ( pNode != NULL )  
9.     {  
10.         pClonedHead = pNode->m_pNext;  
11.         pClonedNode = pNode->m_pNext;  
12.   
13.         pNode->m_pNext = pClonedHead->m_pNext;  
14.         pNode = pNode->m_pNext;  
15.     }  
16.   
17.     while ( pNode )  
18.     {  
19.         pClonedNode->m_pNext = pNode->m_pNext;  
20.   
21.         pNode->m_pNext = pClonedNode->m_pNext;  
22.   
23.         pClonedNode = pClonedNode->m_pNext;  
24.           
25.         pNode = pNode->m_pNext;  
26.     }  
27.   
28.     return pClonedHead;  
29. }  

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

[cpp]  view plain copy print ?

1. ComplexListNode* Clone(ComplexListNode* pHead)  
2. {  
3.     CloneNodes(pHead);  
4.     ConnectSiblingNodes(pHead);  
5.       
6.     return ReconnentNodes(pHead);  
7. }