【剑指offer】10.复杂链表的复制

总目录：

算法之旅导航目录

 

1.问题描述

 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）。 下图是一个含有5个结点的复杂链表。图中实线箭头表示next指针，虚线箭头表示random指针。为简单起见，指向null的指针没有画出。

 

 

示例:

输入:{1,2,3,4,5,3,5,#,2,#}

输出:{1,2,3,4,5,3,5,#,2,#}

解析:我们将链表分为两段，前半部分{1,2,3,4,5}为ListNode，后半部分{3,5,#,2,#}是随机指针域表示。

以上示例前半部分可以表示链表为的ListNode:1->2->3->4->5

后半部分，3，5，#，2，#分别的表示为

1的位置指向3，2的位置指向5，3的位置指向null，4的位置指向2，5的位置指向null

 

2.问题分析

 1使用vector记录输入链表中每个节点的random指向的序号，施加在新链表上，需要提取两个方法用来按节点获取索引和按索引获取节点

2哈希表法？目前未看到可靠的实现

3逐节点伴生，节点映射都是旧节点的下一个，映射完再拆开

3.代码实例

vector+2个方法辅助

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
  public:

    int GetTgtNodeIndex(RandomListNode* pHead, RandomListNode* pTgt) {
        int tgtIndex = -1;
        if (!pTgt) {
            return tgtIndex;
        }

        int indexCounter = 0;
        while (pHead) {
            indexCounter++;
            if (pHead == pTgt) {
                tgtIndex = indexCounter;
                break;
            }

            pHead = pHead->next;
        }
        return tgtIndex;
    }

    RandomListNode* GetTgtNode(RandomListNode* pHead, int index) {
        if (index < 1) {
            return NULL;
        }

        int indexCounter = 0;
        while (pHead) {
            indexCounter++;
            if (indexCounter == index) {
                return pHead;
            }
            pHead = pHead->next;
        }
        return NULL;
    }

    RandomListNode* Clone(RandomListNode* pHead) {
        if (!pHead) {
            return pHead;
        }

        //复制节点,并记录random信息
        RandomListNode* inputNode = pHead;
        RandomListNode* newHead = (RandomListNode*)malloc(sizeof(RandomListNode));
        memset(newHead, 0, sizeof(RandomListNode));
        RandomListNode* pCur = newHead;

        vector<int> ranTgtIndexVec;
        int tgtNodeIndex = 0;

        while (inputNode) {
            //复制数据
            pCur->label = inputNode->label;

            //记录tgt坐标
            tgtNodeIndex = GetTgtNodeIndex(pHead, inputNode->random);
            ranTgtIndexVec.push_back(tgtNodeIndex);

            //是否有下一个节点
            if (inputNode->next) {
                pCur->next = (RandomListNode*)malloc(sizeof(RandomListNode));
                memset(pCur->next, 0, sizeof(RandomListNode));
            } else {
                break;
            }

            //后移
            inputNode = inputNode->next;
            pCur = pCur->next;
        }

        //逐个按索引对ramdom赋值
        pCur = newHead;
        int curNodeINdex = 0;
        while (pCur) {
            pCur->random = GetTgtNode(newHead, ranTgtIndexVec[curNodeINdex++]);
            pCur = pCur->next;
        }

 哈希表

暂无

逐节点伴生再拆分

class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead) {
        if(!pHead) return pHead;    // 为空则返回
        RandomListNode* cur = pHead;
        while(cur){
            RandomListNode* tmp = new RandomListNode(cur->label);    // 拷贝节点
            tmp->next = cur->next;
            cur->next = tmp;
            cur = tmp->next;
        }

        RandomListNode *old = pHead, *clone = pHead->next, *ret = pHead->next;
        while(old){
            clone->random = old->random == NULL ? NULL : old->random->next;    // 处理拷贝节点的随机指针
            if(old->next) old = old->next->next;    // 注意特判空指针，最后一个节点没有->next->next
            if(clone->next) clone = clone->next->next;  // 注意特判空指针，最后一个节点没有->next->next
        }

        old = pHead, clone = pHead->next;
        while(old){    // 拆分链表
            if(old->next) old->next = old->next->next;
            if(clone->next) clone->next = clone->next->next;
            old = old->next;
            clone = clone->next;
        }

        return ret;
    }
};