复杂链表的复制（java版）

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

【节点定义】

/*
public class RandomListNode {
int label;
RandomListNode next = null;
RandomListNode random = null;

RandomListNode(int label) {
this.label = label;
}
}
*/

【解题思路1】

//1.根据每个节点的next指针，先复制链表

//2.遍历新链表，根据原链表random指针，设置新链表中每个节点的random指针

//3.设置random指向位置时，在该方法中采用的是和头结点的相对位置

【源码1】

public class Solution {
public RandomListNode Clone(RandomListNode pHead)
{
if(pHead == null){
return null;
}
RandomListNode inx = pHead;
RandomListNode head = new RandomListNode(inx.label);
RandomListNode index = head;
while(inx.next != null){
inx = inx.next;
RandomListNode tNode = new RandomListNode(inx.label);
index.next = tNode;
index = tNode;
}
inx = pHead;
index = head;
int loc = 0, i=0;
while(inx != null){
RandomListNode temp1 = pHead;
RandomListNode temp2 = head;
if(inx.random == null){
index.random = null;
}else{
loc = randomLoc(temp1, inx.random);      //计算random指向的节点和头结点的相对位置
while(i<loc){
temp2 = temp2.next;
i++;
}
index.random = temp2;
i=0;
}
inx = inx.next;
index = index.next;
}
return head;
}

public int randomLoc(RandomListNode h, RandomListNode target){
int loc = 0;
while(h != target){
loc++;
h = h.next;
}
return loc;
}
}

a. 注意random指针可能为null。

【解题思路2】

//1.根据next指针复制链表。复制的同时，将原节点和新节点建立对应关系

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
public class Solution {
public RandomListNode Clone(RandomListNode pHead)
{
HashMap<RandomListNode,RandomListNode> map = new HashMap<RandomListNode,RandomListNode>();
RandomListNode p = pHead;
RandomListNode q = new RandomListNode(-1);
while(p!=null){
RandomListNode t = new RandomListNode(p.label);
map.put(p, t);
p = p.next;
q.next = t;
q = t;
}
Set<Entry<RandomListNode,RandomListNode>> set = map.entrySet();
Iterator<Entry<RandomListNode,RandomListNode>> it = set.iterator();
while(it.hasNext()){
Entry<RandomListNode, RandomListNode> next = it.next();
next.getValue().random = map.get(next.getKey().random);
}
return map.get(pHead);
}
}

a. random指针可能为null。

b.

next.getValue().random = map.get(next.getKey().random);

是设置新链表random指针的实现部分。

c. 若当前节点的random为null，则有

map.get(null)

的情况出现，此时结果为null， 符合要求。

【解题思路3】

//1.根据原链表中每个节点N创建对应的新节点N’。并把N’链接到N的后面。

//2.设置复制出来的节点random。假设N的random指向节点S，因为N’是N的下一个节点，所以S’也应该为S的下一个节点。

//3.把链表拆分。奇数位置的节点链接起来就是原始的链表。偶数位置的节点链接起来，就是新生成的链表。



【源码3】

链接：https://www.nowcoder.com/questionTerminal/f836b2c43afc4b35ad6adc41ec941dba
来源：牛客网

public class Solution {
public RandomListNode Clone(RandomListNode pHead){
if(pHead==null)
return null;
RandomListNode pCur = pHead;
//复制next 如原来是A->B->C 变成A->A'->B->B'->C->C'
while(pCur!=null){
RandomListNode node = new RandomListNode(pCur.label);
node.next = pCur.next;
pCur.next = node;
pCur = node.next;
}
pCur = pHead;
//复制random pCur是原来链表的结点 pCur.next是复制pCur的结点
while(pCur!=null){
if(pCur.random!=null)
pCur.next.random = pCur.random.next;
pCur = pCur.next.next;
}
RandomListNode head = pHead.next;
RandomListNode cur = head;
pCur = pHead;
//拆分链表
while(pCur!=null){
pCur.next = pCur.next.next;
if(cur.next!=null)
cur.next = cur.next.next;
cur = cur.next;
pCur = pCur.next;
}
return head;
}
}

a.

pCur.next.random = pCur.random.next;

是设置新节点random的实现。

b. 注意设置random时，遍历的实现

pCur = pCur.next.next;