一道奇妙的链表复制问题

最近看到一道有关链表复制的算法题，解法很是奇妙。

题目：已知一链表，每个节点除了有一个指向下一节点的指针外，还有一随机指针指向链表中的任意节点（可能为空，也有可能为自身），请复制一个链表，要求节点的顺序以及节点上的随机指针指向的节点位置和原链表一致。

解法一：

空间换时间，利用数组、链表等数据结构存储Random指针位置信息，这里样例代码使用Hash表，这样空间利用率是O（n），时间效率也是O（n）。

1. #include <hash_map>
3. using namespace std;
4. using namespace stdext;
6. struct Node
7. {
8.     Node* pNext;
9.     Node* pRandom;
10. };
12. Node* Copy(Node* pHead)
13. {
14.     if (pHead = NULL)
15.         return NULL;
17.     // 额外存储空间，利用Hash方法达到常数级的查找开销
18.     hash_map<Node*, int> NodeMap;
19.     int nIndex = 0;
20.     Node* pNode = pHead;
22.     // 将链表存入map中，并记录下编号
23.     while (pNode != NULL)
24.     {
25.         if (NodeMap.insert(hash_map<Node*, int>::value_type(pNode, nIndex)).second)
26.         {
27.             nIndex++;
28.             pNode = pNode->pNext;
29.         }
30.         else // 到达环的交点
31.             break;
32.     }
34.     Node* pNewNodes = new Node[NodeMap.size()];
36.     // 顺序复制每个节点的指针
37.     nIndex = 0;
38.     for (hash_map<Node*, int>::iterator it = NodeMap.begin(); it != NodeMap.end(); it++, nIndex++)
39.     {
40.         int nNext = 0, nRandom = 0;
41.         Node* pOriginal = it->first;
43.         // 复制Next
44.         if (pOriginal->pNext != NULL)
45.         {
46.             hash_map<Node*, int>::iterator temp = NodeMap.find(pOriginal->pNext);
47.             pNewNodes[nIndex].pNext = &pNewNodes[temp->second];
48.         }
49.         else
50.             pNewNodes[nIndex].pNext = NULL;
52.         // 复制Random
53.         if (pOriginal->pRandom != NULL)
54.         {
55.             hash_map<Node*, int>::iterator temp = NodeMap.find(pOriginal->pRandom);
56.             pNewNodes[nIndex].pRandom = &pNewNodes[temp->second];
57.         }
58.         else
59.             pNewNodes[nIndex].pRandom = NULL;
60.     }
62.     return pNewNodes;
63. }

解法二：

此方法的中心思想是把原始链表和复制链表先合并为一个有固定顺序的链表，然后给复制链表中每个节点的随机指针复制，最后再打断链表恢复原样。和解法一相比，空间效率上更佳。

代码如下：

1. typedef struct __Node {
2.     int nData;
3.     __Node* pNext;
4.     __Node* pRandom;
5. } Node;
7. Node* DuplicateList(Node* pSrcListHead)
8. {
9.     if (pSrcListHead == NULL)
10.         return NULL;
11.     
12.     Node* pNode = pSrcListHead;
13.     while (pNode != NULL)
14.     {
15.         Node* pNewNode = new Node;
16.         pNewNode->nData = pNode->nData;
18.         pNewNode->pNext = pNode->pNext;
19.         pNewNode->pRandom = pNode->pRandom;
21.         pNode->pNext = pNewNode;
22.         pNode = pNewNode->pNext;
23.     }
24.     
25.     Node* pDestListHead = pSrcListHead->pNext;
26.     pNode = pSrcListHead;
27.     while (pNode != NULL)
28.     {
29.         pNode->pNext->pRandom = pNode->pRandom->pNext;
30.         pNode = pNode->pNext->pNext;
31.     }
33.     pNode = pSrcListHead;
34.     Node* pNode2 = pNode->pNext;
35.     while (pNode != NULL)
36.     {
37.         pNode->pNext = pNode2->pNext;
38.         pNode = pNode->pNext;
40.         if (Node)
41.             pNode2->pNext = pNode->pNext;
42.         else
43.             pNode2->pNext = NULL;
44.         pNode2 = pNode2->pNext;
45.     }
47.     return pDestListHead;
48. }

不过目前还未考虑到原始链表有环的情况，如果原始链表有环，则应该先求出环的入口点，然后利用上面的方法进行链表复制，在这里就不详细列出代码了。