复杂链表复制

//复杂链表的复制
#pragma once

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>

typedef struct ComplexNode {
	int	data;
	struct ComplexNode	*pNext;
	struct ComplexNode	*pRandom;
}	CN;


CN	* Copy(CN *pFirst)
{
	CN	*pNode;
	CN	*pNewNode;
	CN	*pOldRandom;
	CN	*pNewRandom;

	// 1. 复制结点，放到老结点后边
	for (pNode = pFirst; pNode != NULL; pNode = pNode->pNext->pNext) {
		pNewNode = (CN *)malloc(sizeof(CN));
		assert(pNewNode);
		pNewNode->data = pNode->data;
		pNewNode->pRandom = NULL;

		pNewNode->pNext = pNode->pNext;
		pNode->pNext = pNewNode;
	}

	// 2. 复制 pRandom
	for (pNode = pFirst; pNode != NULL; pNode = pNode->pNext->pNext) {
		pNewNode = pNode->pNext;
		pOldRandom = pNode->pRandom;
		if (pOldRandom != NULL) {
			pNewRandom = pOldRandom->pNext;
			pNewNode->pRandom = pNewRandom;
		}
	}

	//	3. 拆链表
	CN	*pNewFirst = pFirst->pNext;
	for (pNode = pFirst; pNode != NULL; pNode = pNode->pNext) {
		pNewNode = pNode->pNext;

		pNode->pNext = pNewNode->pNext;
		if (pNode->pNext != NULL) {
			pNewNode->pNext = pNode->pNext->pNext;
		}
		else {
			pNewNode->pNext = NULL;
		}
	}

	return pNewFirst;
}

CN	* Buy(int data)
{
	CN	*pNode = (CN *)malloc(sizeof(CN));
	assert(pNode);
	pNode->data = data;
	pNode->pRandom = NULL;
	pNode->pNext = NULL;

	return pNode;
}

void Print(CN *pFirst)
{
	CN	*pNode;
	for (pNode = pFirst; pNode; pNode = pNode->pNext) {
		printf("[%d, (%p, %d)] ",
			pNode->data,
			pNode->pRandom,
			pNode->pRandom ? pNode->pRandom->data : 0);
	}
	printf("\n");
	printf("pFisrt:[%d,(%p, %d)]",
		pFirst->data,
		pFirst->pRandom,
		pFirst->pRandom ? pFirst->pRandom->data : 0);
}

void TestCN()
{
	CN	*p1 = Buy(1);
	CN	*p2 = Buy(2);
	CN	*p3 = Buy(3);
	CN	*p4 = Buy(4);

	p1->pNext = p2;
	p2->pNext = p3;
	p3->pNext = p4;

	p1->pRandom = p4;
	p4->pRandom = p1;
	p2->pRandom = p2;

	//Print(p1);

	CN	*pNew = Copy(p1);

	Print(pNew);
}



//在牛客网的oj环境下编译通过的
//void CloneRandom(RandomListNode* pHead){
//	RandomListNode* pCloned;
//	while (pHead != NULL){
//		pCloned = pHead->next;
//		if (pHead->random != NULL){
//			pCloned->random = pHead->random->next;
//		}
//		pHead = pCloned->next;
//	}
//}
//
//RandomListNode* ReConnectNodes(RandomListNode* pHead){
//	RandomListNode* pClonedHead = NULL;
//	RandomListNode* pClonedNode = NULL;
//	RandomListNode* pNode = pHead;
//
//	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;
//}