复杂链表的复制（C 语言 和 Java 语言）

     所谓的复杂链表指的是一个链表有若干各节点，每一个节点右移个数据域专门用来存放数据，还有两个指针域其中一个纸箱下一个结点，还有一个随机指向当前复杂链表中的任意一个结点或者是一个空节点。

如下图所示，就是一个复杂链表：

 

解题思路：

1.定义链表结构：

 

 2.把要拷贝的结点插入该链表

在完成该操作之后，新链表的random就在原来链表的random之后了

3.拆分链表：

 这样就复杂链表就复制好了

C语言完整代码：

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int DataType;

//复杂链表结点的结构
typedef struct ComplexNode{
	DataType data;
	struct ComplexNode *next;
	struct ComplexNode *random;
}ComplexNode;


//创建复杂链表
ComplexNode *BuyComplex(DataType data){
	ComplexNode *node = (ComplexNode *)malloc(sizeof(ComplexNode));
	assert(node!=NULL);
	node->data = data;
	node->next = NULL;
	node->random = NULL;
	return node;
}


//复制复杂链表
ComplexNode *CloneComplexList(ComplexNode *cHead)
{
	ComplexNode *cur = cHead;
	while (cur){
		ComplexNode *next = cur->next;
		ComplexNode *clone = BuyComplex(cur->data);
		cur->next = clone;
		clone->next = next;
		cur = next;

	}
	//这样的话，拷贝的结点的random一定在被拷贝结点的random之后
	cur = cHead;
	while (cur){
		ComplexNode *clone = cur->next;
		if (cur->random != NULL){
			clone->random = cur->random->next;
		}
		cur = clone->next;
	}
	//把新旧链表拆开，先拆一个结点当头
	cur = cHead;
	ComplexNode *cloneHead = NULL;//作为新链表的头
	ComplexNode *cloneTail = NULL;//作为新链表的尾
	while (cur){
		ComplexNode *clone = cur->next;
		ComplexNode *next = clone->next;
		cur->next = next;
		if (cloneHead == NULL){
			cloneHead = clone;
			cloneTail = clone;
		}
		else{
			cloneTail->next = clone;
			cloneTail = clone;
		}
		cur = next;
	}

}

void Test()
{
	ComplexNode* node1 = BuyComplex(1);
	ComplexNode* node2 = BuyComplex(2);
	ComplexNode* node3 = BuyComplex(3);
	ComplexNode* node4 = BuyComplex(4);


	node1->next = node2;
	node2->next = node3;
	node3->next = node4;

	node1->random = node3;
	node2->random= node4;
	node3->random = node2;
	node4->random = node1;   //1->3 2->4  3->2  4->1

	ComplexNode* test = CloneComplexList(node1);
}

Java语言：

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;
        }
         
        RandomListNode currentNode = pHead;
        //1、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面；
        while(currentNode != null){
            RandomListNode cloneNode = new RandomListNode(currentNode.label);
            RandomListNode nextNode = currentNode.next;
            currentNode.next = cloneNode;
            cloneNode.next = nextNode;
            currentNode = nextNode;
        }
         
        currentNode = pHead;
        //2、重新遍历链表，复制老结点的随机指针给新结点，如A1.random = A.random.next;
        while(currentNode != null) {
            currentNode.next.random = currentNode.random==null?null:currentNode.random.next;
            currentNode = currentNode.next.next;
        }
         
        //3、拆分链表，将链表拆分为原链表和复制后的链表
        currentNode = pHead;
        RandomListNode pCloneHead = pHead.next;
        while(currentNode != null) {
            RandomListNode cloneNode = currentNode.next;
            currentNode.next = cloneNode.next;
            cloneNode.next = cloneNode.next==null?null:cloneNode.next.next;
            currentNode = currentNode.next;
        }
         
        return pCloneHead;
    }
}