剑指Offer+第26题+复杂链表的复制+java

题目：

请实现函数ComplexListNode* Clone(ComplexListNode * pHead),复制一个复杂链表。在复杂链表中，每个结点除了有一个m_pNext指针指向下一个结点外，还有一个m_pSibling指向链表中的任意结点或者NULL。

上图是一个含有5个结点的复杂链表。图中实线箭头表示m_pNext指针，虚线箭头表示m_pSibling指针。为了简单起见，指向NULL的指针没有画出。

第一思路：

把复杂链表的复制分为两步：第一步是复制原始链表上的每一个结点，并用m_pNext连接起来；第二步是设置m_pSibling指向结点S，由于S的位置在链表中可能在N的前面也可能在N的后面，所以要定位S的位置需要从原始链表的头结点开始找。如果从原始链表的头结点开始沿着m_pNext经过s步找到结点S，那么在复制链表上结点N'的m_pSibling（记为S'）离复制链表的头结点的距离也是沿着m_pNext指针s步。用这种办法我们就可以为复制链表上的每个结点设置m_pSibling指针。对于每一个含有n个结点的链表，由于定位每个结点的m_pSibling都需要从链表头结点开始经过O(n)步才能找到，因此这种方法的总时间复杂度是O(n^2)。

优化思路：

上面的时间为主要花在定位结点的m_pSibling上面，所以我们能优化的地方也只有这个地方。我们还是分为两步：第一步仍然是复制原始链表上的每个结点N创建N'，然后把这些创建出来的结点用m_pNext链接起来。同时我们把<N, N'>的配对信息放到一个哈希表中。第二步还是设置复制链表上的每个结点的m_pSibling。如果在原始链表中结点N的m_pSibling指向结点S，那么在复制链表中，对应的N'应该指向S'。由于有了哈希表，我们可以在O(1)的时间根据S找到S’。这种是以O(n)的空间换来了O（n）的时间复杂度。
 

代码可见 https://blog.csdn.net/u013132035/article/details/80625419

最优思路：

不用O(n)的空间复杂度来实现O(n)的时间效率。

第一步：让仍然是根据原始链表的每个结点N创建对应的N'。不过我们把N’链接在N的后面。

第二步：设置复制出来的结点的m_pSibling。原始链表上的A的m_pSibling指向结点C，那么其对应复制出来的A’是A的m_pNext指向的结点，同样C’也是C的m_pNext指向的结点。即A' = A.next，A'.m_pSibling = A.m_pSibling.next；故像这样就可以把每个结点的m_pSibling设置完毕。

第三步：将这个长链表拆分成两个链表：把奇数位置的结点用m_pNext链接起来就是原始链表，把偶数位置的结点用m_pNext链接起来就是复制出来的链表。

代码：

package LinkedList;

public class Offer26 {

	//复杂链表的节点定义
	public static class ComplexListNode{
		int value;
		ComplexListNode next = null;
		ComplexListNode sibling =null;
		
		ComplexListNode(){}
		
		ComplexListNode(int val){
			super();
			this.value = val;
		}
		
		@Override
		public String toString(){
			StringBuilder sb = new StringBuilder();
			sb.append(" value= "+ value);
			sb.append(", next= "+(next ==null ? "null":next.value));
			sb.append(", sibling=" +(sibling == null? "null":sibling.value));
			return sb.toString();
		}
	}
	
	//复制链表第一步,根据原始结点A在其后面创建A'。
	public void cloneNodes(ComplexListNode pHead){
		ComplexListNode pNode = pHead;
		while(pNode != null){
			//创建pCloned结点即A'结点使其指向原始链表中A结点的下一结点B,不过A'的m_pSibling设置为null
			ComplexListNode pCloned = new ComplexListNode();//新增加一个节点
			pCloned.value = pNode.value;
			pCloned.next = pNode.next;
			pCloned.sibling = null;
			
			//将A结点指向A’结点
			pNode.next = pCloned;
			//使pNode指向A的下一结点B并以此循环修改(此时中间已将克隆结点A‘插入了原始列表)
			pNode = pCloned.next;
		}
	}
	
	//设置每个结点的m_pSibling(注：m_pSibling为空结点不做修改)
	public void connectSiblingNodes(ComplexListNode pHead){
		ComplexListNode pNode = pHead;
		while(pNode != null){
			ComplexListNode pCloned = pNode.next;
			if(pNode.sibling != null){
				pCloned.sibling = pNode.sibling.next;
			}
			pNode = pCloned.next;
		}
	}
	
	
	//拆分链表
	public ComplexListNode reconnectNodes(ComplexListNode pHead){
		ComplexListNode pNode = pHead;
		ComplexListNode pClonedHead = null;
		ComplexListNode pClonedNode = null;
		if(pNode != null){
			pClonedHead = pClonedNode = pNode.next;
			pNode.next = pClonedNode.next;
			pNode = pNode.next;
		}
		while(pNode != null){
			pClonedNode.next = pNode.next;
			pClonedNode = pClonedNode.next;
			pNode.next = pClonedNode.next;
			pNode = pNode.next;
		}
		return pClonedHead;
	}
	
	public ComplexListNode clone(ComplexListNode pHead){
		if(pHead == null)
			System.out.println("linkedlist is null");
		cloneNodes(pHead);
		connectSiblingNodes(pHead);
		return reconnectNodes(pHead);
	}
	
	
	
	public static void main(String[] args) {

		Offer26 of26 = new Offer26();
		
		//功能测试，1，节点中的sibling指向节点自身
		ComplexListNode node11 = new ComplexListNode(1);
		ComplexListNode node12 = new ComplexListNode(2);
		ComplexListNode node13 = new ComplexListNode(3);
		
		node11.next = node12;
		node11.sibling = node11;
		node12.next = node13;
		
		ComplexListNode tempNode11 = of26.clone(node11);
		
		while(tempNode11 != null){
			System.out.println(tempNode11);
			tempNode11 = tempNode11.next;
		}
		System.out.println();
		
		//功能测试，2，两个节点的sibling形成环状结构
		ComplexListNode node21 = new ComplexListNode(1);
		ComplexListNode node22 = new ComplexListNode(2);
		ComplexListNode node23 = new ComplexListNode(3);
		
		node21.next = node22;
		node21.sibling = node23;
		node22.next = node23;
		node23.sibling = node21;
		
		ComplexListNode tempNode21 = of26.clone(node21);
		
		while(tempNode21 != null){
			System.out.println(tempNode21);
			tempNode21 = tempNode21.next;
		}
		System.out.println();
		
		//功能测试，2，链表中只有一个节点
		ComplexListNode node31 = new ComplexListNode(1);
		
		ComplexListNode tempNode31 = of26.clone(node31);
		
		while(tempNode31 != null){
			System.out.println(tempNode31);
			tempNode31 = tempNode31.next;
		}
		System.out.println();
		
		//特殊输入测试，指向链表头节点的指针为NULL
		ComplexListNode node41 = null;
		
		ComplexListNode tempNode41 = of26.clone(node41);
		
		while(tempNode41 != null){
			System.out.println(tempNode41);
			tempNode41 = tempNode41.next;
		}
		System.out.println();

	}

}

 

运行结果：

 value= 1, next= 2, sibling=1
 value= 2, next= 3, sibling=null
 value= 3, next= null, sibling=null

 value= 1, next= 2, sibling=3
 value= 2, next= 3, sibling=null
 value= 3, next= null, sibling=1

 value= 1, next= null, sibling=null

linkedlist is null