数据结构---单链表（3）

1.复杂链表的复制（剑指offer-26）

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

struct ComplexNode

{

    int m_nValue;

    ComplexNode* m_pNext;

    ComplexNode* m_pSibling;

};

java定义：

	// 复杂链表结点（内部类）
	static class ComplexNode {

		int m_Value; // 该节点存储的值。
		ComplexNode m_pNext;
		ComplexNode m_pSibling;

		ComplexNode() {
			this.m_pNext = null;
			this.m_pSibling = null;
		}

		ComplexNode(int value) {
			this.m_Value = value;
			this.m_pNext = null;
			this.m_pSibling = null;
		}

	}

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

	public static void CloneNodes(ComplexNode pHead) {
		ComplexNode p = pHead;
		while (p != null) {
			ComplexNode pCloned = new ComplexNode();

			pCloned.m_Value = p.m_Value;
			pCloned.m_pNext = p.m_pNext;
			p.m_pNext = pCloned;
			pCloned.m_pSibling = null;

			p = pCloned.m_pNext;
		}
	}

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

	public static void ConnectSiblingNodes(ComplexNode pHead) {
		ComplexNode p = pHead;
		ComplexNode pCloned = null; // 记录当前要确定其m_pSibling的结点

		while (p != null) {
			pCloned = p.m_pNext;

			if (p.m_pSibling != null)
				pCloned.m_pSibling = p.m_pSibling.m_pNext;

			p = pCloned.m_pNext;
		}
	}

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

	public static ComplexNode ReconnentNodes(ComplexNode pHead) {
		ComplexNode pNode = pHead;
		ComplexNode pClonedHead = null; // 确定返回的头结点
		ComplexNode 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 != null) {
			pClonedNode.m_pNext = pNode.m_pNext;			
			pClonedNode = pClonedNode.m_pNext;
			pNode.m_pNext = pClonedNode.m_pNext;
			pNode = pNode.m_pNext;
		}

		return pClonedHead;
	}

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

	public static ComplexNode Clone(ComplexNode pHead)  
	{  
	    CloneNodes(pHead);  
	    ConnectSiblingNodes(pHead);  
	    return ReconnentNodes(pHead);  
	}  

参考来源：

复杂链表的复制