复杂链表复制

在链表中，有一类链表叫做复杂链表，复杂链表的每个节点有两个指针，一个指向下一个节点，一个指向随机节点，可以指向NULL，也可以指向已经存在的链表节点，可以指向本节点之前的节点，也可以指向之后的节点。
节点的结构声明如下：

typedef int DataType;类型名重定义，也可以使用template

typedef struct ComplexNode{

    DataType _data; // 数据 
    struct ComplexNode * _next; // 指向下一个节点的指针 
    struct ComplexNode * _random; // 指向随机节点（可以是链表中的任意节点 or 空） 
    ComplexNode(DataType x = 0)
        :_data(x)
        , _next(NULL)
        , _random(NULL)
    {}
}ComplexNode;

在网上大部分的复杂链表复制分为两种:
第一种：
使用STL中的map容器，在容器中存储顺序节点指针和随机访问节点。
第二种：
在每个节点存储一个该节点的拷贝，顺序好像1->2->3->NULL,变为1->1->2->2->3->3->NULL;
然后保证复制节点的随机访问指向对应的节点的复制节点的位置上，然后对连表进行拆分，变为原链表和复制链表，这样我们的复杂链表复制就完成了。
具体过程·：

具体代码，测试如下：

include<cstdlib>
#include<iostream>
#include<cassert>
using namespace std;

typedef int DataType;

typedef struct ComplexNode{

    DataType _data; // 数据 
    struct ComplexNode * _next; // 指向下一个节点的指针 
    struct ComplexNode * _random; // 指向随机节点（可以是链表中的任意节点 or 空） 
    ComplexNode(DataType x = 0)
        :_data(x)
        , _next(NULL)
        , _random(NULL)
    {}
}ComplexNode;

ComplexNode* Comclone(ComplexNode* head)
{
    assert(head);
    ComplexNode* phead = head;
    ComplexNode* pnext = head->_next;
    while (phead)//拷贝链表每个节点到原节点后面1-2-3>>1-1-2-2-3-3
    {
        ComplexNode* temp = new ComplexNode(head->_data);
        phead->_next = temp;
        temp->_next = pnext;
        phead = temp->_next;
        if (phead)
        {
            pnext = phead->_next;
        }
    }
    phead = head;
    while (phead)//解决随机指向指针的指向
    {
        if (!phead->_random)
            phead->_next->_random = NULL;
        else
            phead->_next->_random = phead->_random->_next;
        phead = phead->_next->_next;
    }
    ComplexNode* chead = head->_next;
    ComplexNode* cnode = head->_next;
    phead = head;
    while (phead)
    {
        phead->_next = chead->_next;
        phead = phead->_next;
        if (phead)
        {
            chead->_next = phead->_next;
            chead = chead->_next;
        }
    }
    chead = cnode;
    return chead;
}

void Printf(ComplexNode* head)
{
    assert(head);
    while (head)
    {
        if (head->_random == NULL)
        {
            cout << "head->_data:" << head->_data << " " << "head->_random:" << "NULL" << endl;
        }
        else
        {
            cout << "head->_data:" << head->_data<< " " << "head->_random:" << head->_random->_data << endl;
        }
        head = head->_next;
    }
}

void test()
{
    ComplexNode* head1 = new ComplexNode(1);
    ComplexNode* node1 = new ComplexNode(2);
    ComplexNode* node2 = new ComplexNode(3);
    ComplexNode* node3 = new ComplexNode(4);
    ComplexNode* node4 = new ComplexNode(5);
    head1->_next = node1;
    node1->_next = node2;
    node2->_next = node3;
    node3->_next = node4;
    node4->_next = NULL;
    node1->_random = node4;
    node2->_random = node3;
    ComplexNode* ret=Comclone(head1);
    Printf(head1);
}

int main()
{
    test();
    system("pause");
    return 0;
}