C++实现复杂链表的复制

一、什么是复杂链表

复杂链表的每个结点具有三个成员，分别是存放数据的data和指向下一个结点的指针和指向随机节点的指针。
复杂结点的结构：

template <class T>
struct ListNode
{
    T data;
    ListNode<T>* next;
    ListNode<T>* random;
    ListNode(const T& d)
        :data(d)
        ,next(NULL)
        ,random(NULL)
    {}
};

二、复杂链表的复制

那么我们如何把复杂链表进行复制呢，以下提出了三种方法。

方法一：

直接复制，时间复杂度为O（N^2）。

直接复制就是先把链表遍历一遍，复制每个结点，并且通过next指针链接起来每个结点，再把每个结点的随即指针进行复制，所以循环了两遍，造成了时间复杂度的增加。

方法二：

存储随即结点的信息，时间复杂度为O（N）。

把键值的信息存储到另外一个地方，采用类似hash的方法，用空间换取时间，把原始链表的和复制链表的结点通过哈希对应起来，争取在查找随即结点的时间上更少，所以查找时间由O（N）变为O（1）。
然后复制原始链表的每个结点，并且通过next指针链接起来，最后根据我们保存的信息把复杂链表的随机指针进行设置即可。
此种方法由于我们把查找时间变少，所以总的效率变高了。

方法三：

巧妙复制，时间复杂度为O（N）。

此种方法和第二种方法时间复杂度上类似，但是实现的方法更巧妙，因为我们不再借助另外的辅助空间来实现，它的实现主要分为以下三步。

①第一步

按照顺序复制每一个结点，并且把复制过的结点放在被复制结点的next指针后面

void CloneNodes(Node* pHead)
{
    Node* temp;
    Node* cur = pHead;
    while (cur)
    {
        //注意链接顺序
        temp = new Node(cur->data);
        temp->next = cur->next;
        cur->next = temp;
        cur = temp->next;
    }
}

②第二步

复制其中的随机指针

void UpdateNewNodeRandom(Node* pHeat)
{
    Node* cur = pHeat;
    while (cur)
    {
        Node* Next = cur->next;//调整使它指向新结点
        if (cur->random != NULL)//如果随即指针存在复制
            //cur的随机指针指向的下一个位置既是Next的随即指针
            Next->random = cur->random->next;
        cur = Next->next;//调整cur向下一个
    }
}

③第三步

分开上下两个单链表

Node* ReconnectNode(Node* pHead)
{
    Node* cur = pHead;//原来头
    Node* temp = NULL;//复制出来的结点
    Node* NewHead = NULL;//新链表头结点
    if (cur)
    {
        temp = cur->next;
        NewHead = cur->next;
        cur->next = temp->next;
        cur = temp->next;
    }
    while (cur)
    {
        temp->next = cur->next;//调整temp的下一个

        temp = temp->next;//更新temp
        cur->next = temp->next;//调整cur的下一个
        cur = temp->next;//更新cur
    }
    return NewHead;//返回链表头结点
}

最后只需要把三个步骤汇总在一起即可达到目的。

Node* CopyList(Node* pHead)
{
    if (pHead)
    {
        CloneNodes(pHead);
        UpdateNewNodeRandom(pHead);
        ReconnectNode(pHead);
    }
    return NULL;
}

三、实现代码

#include <iostream>
using namespace std;
template <class T>
struct ListNode
{
    T data;
    ListNode<T>* next;
    ListNode<T>* random;
    ListNode(const T& d)
        :data(d)
        , next(NULL)
        , random(NULL)
    {}
};

template <class T>
class List
{
    typedef ListNode<T> Node;
public:
    List()
    {}
    List(Node LinkNode, T data)
    {
        Node temp=new (Node*)Node(sizeof(Node));
        temp->next = NULL;
        temp->random = NULL;
        LinkNode->next = temp;
    }
    Node* CopyList(Node* pHead)
    {
        if (pHead)
        {
            CloneNodes(pHead);
            UpdateNewNodeRandom(pHead);
            ReconnectNode(pHead);
        }
        return NULL;
    }
    Node* CreatList()
    {
        Node* Node1 = new Node(1);    //创建节点  
        Node* Node2 = new Node(2);
        Node* Node3 = new Node(3);
        Node* Node4 = new Node(4);
        Node* Node5 = new Node(5);

        Node1->next = Node2;       //连接节点  
        Node2->next = Node3;
        Node3->next = Node4;
        Node4->next = Node5;

        Node1->random = Node3;    //置_random  
        Node2->random = Node4;
        Node3->random = Node1;
        Node4->random = Node5;
        Node5->random = Node2;

        return Node1;            //返回头  
    }

private:
    //第一步
    void CloneNodes(Node* pHead)
    {
        Node* temp;
        Node* cur = pHead;
        while (cur)
        {
            //注意链接顺序
            temp = new Node(cur->data);
            temp->next = cur->next;
            cur->next = temp;
            cur = temp->next;
        }
    }
    //第二步
    void UpdateNewNodeRandom(Node* pHeat)
    {
        Node* cur = pHeat;
        while (cur)
        {
            Node* Next = cur->next;//调整使它指向新结点
            if (cur->random != NULL)//如果随即指针存在复制
                //cur的随机指针指向的下一个位置既是Next的随即指针
                Next->random = cur->random->next;
            cur = Next->next;//调整cur向下一个
        }
    }
    //第三步
    Node* ReconnectNode(Node* pHead)
    {
        Node* cur = pHead;//原来头
        Node* temp = NULL;//复制出来的结点
        Node* NewHead = NULL;//新链表头结点
        if (cur)
        {
            temp = cur->next;
            NewHead = cur->next;
            cur->next = temp->next;
            cur = temp->next;
        }
        while (cur)
        {
            temp->next = cur->next;//调整temp的下一个

            temp = temp->next;//更新temp
            cur->next = temp->next;//调整cur的下一个
            cur = temp->next;//更新cur
        }
        return NewHead;//返回链表头结点
    }
private:
    Node* LinkNode;
};