剑指offer-复杂链表的复制

题目描述

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

思路1：暴力求解法（时间复杂度为o(n**2))

step1:复制原始链表上的每一个节点，然后把它们用next连接起来。

step2:设置每个节点的random节点指针。

对于一个含有N个节点的链表，定位每个节点的random都需要从头结点开始遍历，经过o(n)步才可以找到，因此这个方法的时间复杂度是o(n**2).

代码：

 public RandomListNode Clone0(RandomListNode pHead){
	if(pHead==null) return null;
	RandomListNode pCloneHead=new RandomListNode(pHead.label);
	RandomListNode pNode = pHead, pClonedNode = pCloneHead;
	while(pNode.next!=null){
		pClonedNode.next=new RandomListNode(pNode.next.label);
//		pClonedNode.random=new RandomListNode(pNode.random.label);//这样克隆的节点id不一样，所以并不是同一个节点
		pNode=pNode.next;
		pClonedNode=pClonedNode.next;
	}
	pNode = pHead;
	pClonedNode=pCloneHead;
	RandomListNode p1=pHead; RandomListNode p2=pCloneHead;
	while(pNode!=null){
		if(pNode.random==null){
			pClonedNode.random=null;
		}else{
			while(pNode.random!=p1){
				p1=p1.next;
				p2=p2.next;
			}
			pClonedNode.random=p2;
		}
		pNode=pNode.next;
		pClonedNode=pClonedNode.next;
		p1=pHead;
		p2=pCloneHead;
		
	}
	return pCloneHead;
	 
 }

 

思路2：借助外部空间，用o(n)的空间将时间复杂度由o(n**2)降到o(n)

step1:创建链表上的每个节点N创建N',然后把这些创建出来的节点用next连接起来，同时再将<N,N'>的配对信息放入哈希表。

step2:设置复制链表上每个节点的random指针，因为有了哈希表，所以可以用o(1)的时间根据s找到s'.

这种思路就是用空间换时间，N个节点需要开辟一个o(n)大小的哈希表空间，来换取时间复杂度的降低。

实现1：

//利用外部空间，将算法由o(n**2)降到o(n)
import java.util.HashMap;
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead==null){
            return null;
        }
        //复制原链表的节点N，并将这些节点用next节点连接起来
        HashMap<RandomListNode,RandomListNode> map=new HashMap<>();
        RandomListNode pClonedHead=new RandomListNode(pHead.label);
        RandomListNode pNode=pHead,pClonedNode=pClonedHead;
        map.put(pNode,pClonedNode);
        //hashMap保存后，原链表节点映射复制链表节点
        while(pNode.next!=null){
            pClonedNode.next=new RandomListNode(pNode.next.label);
            pNode=pNode.next;
            pClonedNode=pClonedNode.next;
            map.put(pNode,pClonedNode);
        }
        //为复制出来的N'赋值它的random
        pNode=pHead;
        pClonedNode=pClonedHead;
        while(pClonedNode!=null){
            pClonedNode.random=map.get(pNode.random);
            pNode=pNode.next;
            pClonedNode=pClonedNode.next;           
        }
        return pClonedHead;      
    }
}

 

思路3：不开辟新空间，通过复制原节点，再连接到它后面，组成一个原节点+复制节点的链表。

step1:通过原始链表的每个节点N，创建N'。（把N'链接到N的后面）

step2:根据原节点的random指针的指向来设置复制处理的节点的random指针指向。

原始链表上A的random指向结点C，复制出来的A’是A的next指向的节点，同样C'也是C的next指向的节点，即A'=A.next,A'.random=A.random.next,用这样的方式就可以把每个结点的random设置完毕。

step3:拆分链表

将上图对应的长链表拆分成原链表和复制链表两个链表。

实现2：

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;
 
    RandomListNode(int label) {
        this.label = label;
    }
}
*/
public class Solution {
    public RandomListNode Clone(RandomListNode pHead)
    {
        if(pHead==null){
            return null;
        }
        cloneNodes(pHead);
        connectRandomNodes(pHead);
        return reconnectNodes(pHead);      
    }
    //根据原始节点在其后面创建复制节点A'
    private void cloneNodes(RandomListNode pHead){
        RandomListNode pNode=pHead;
        while(pNode!=null){
            RandomListNode pClonedNode=new RandomListNode(0);
            pClonedNode.label=pNode.label;
            pClonedNode.next=pNode.next;
            pClonedNode.random=null;//复制节点，并用next连接，它的random指针先初始化为null
            pNode.next=pClonedNode;
            pNode=pClonedNode.next;
        }
    }
    //为每个节点设置random(random为空的节点不做修改)
    private void connectRandomNodes(RandomListNode pHead){
        RandomListNode pNode=pHead;
        while(pNode!=null){
            RandomListNode pClonedNode=pNode.next;
            if(pNode.random!=null){
                pClonedNode.random=pNode.random.next;             
            }
            pNode=pClonedNode.next;
        }
    }
    //拆分链表
    private RandomListNode reconnectNodes(RandomListNode pHead){
        //当前链表是原链表和复制链表组成的连接链表
        RandomListNode pNode=pHead;
        RandomListNode pClonedNode=null;
        RandomListNode pClonedHead=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;
    }
}

 

 

测试方法：

//测试代码辅助方法封装
	private static void BuildNodes(RandomListNode node,RandomListNode next,RandomListNode random){
		if(node!=null){
			node.next=next;
			node.random=random;
		}
	}
	
	private static void PrintList(RandomListNode head){
		RandomListNode node=head;
		while(node!=null){
			System.out.println("The value of this node is: "+node.label);
			if(node.random!=null){
				System.out.println("The value of it's random is: "+node.random.label);
			}else{
				System.out.println("this node does not have a random");
			}
			System.out.println();
			node=node.next;
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//测试代码
		RandomListNode node1=new RandomListNode(1);
		RandomListNode node2=new RandomListNode(2);
		RandomListNode node3=new RandomListNode(3);
		RandomListNode node4=new RandomListNode(4);
		RandomListNode node5=new RandomListNode(5);
		
		BuildNodes(node1, node2, node3);
		BuildNodes(node2, node3, node5);
		BuildNodes(node3, node4, null);
		BuildNodes(node4, node5, node2);
		
		Solution s=new Solution();
		RandomListNode clonehead=s.Clone(node1);
		PrintList(clonehead);
		
		
		

	}

测试结果：

 

 

参考博客：

https://www.cnblogs.com/edisonchou/p/4790090.html