LeetCode: Copy List with Random Pointer

最新推荐文章于 2020-03-05 04:14:26 发布

原创最新推荐文章于 2020-03-05 04:14:26 发布 · 689 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

186 篇文章

订阅专栏

本文介绍了一种带有随机指针的链表深拷贝方法。通过三种不同的实现方案，包括不使用额外空间的巧妙方法及利用哈希映射的直接方式，详细解释了如何在保持原有链表结构的同时创建全新的链表副本。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

  struct RandomListNode {
      int label;
      RandomListNode *next, *random;
      RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
  };
 class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if(head == NULL)
            return head;
        RandomListNode* cur = head;
        while(cur != NULL)
        {
			RandomListNode* tmp = new RandomListNode(cur->label);
			tmp->next = cur->next;
			cur->next = tmp;
			cur = tmp->next;
        }
		cur = head;

		while(cur != NULL)
		{
			if(cur->random == NULL)
			{
				cur->next->random = NULL;
			}
			else
			{
				cur->next->random = cur->random->next;
			}
			cur = cur->next->next;
		}
		cur = head;
		RandomListNode* result = cur->next;
		while(cur->next != NULL)
		{
			RandomListNode* tmp = cur->next;
			cur->next = cur->next->next;
			cur = tmp;
		}
		return result;

    }
};

Round 2:

Using extra memory space

/**
 * Definition for singly-linked list with a random pointer.
 * struct RandomListNode {
 *     int label;
 *     RandomListNode *next, *random;
 *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
 * };
 */
class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if(head == NULL){
            return NULL;
        }
        unordered_map<RandomListNode*, RandomListNode*> m_map;
        RandomListNode *newHead = new RandomListNode(head->label);
        RandomListNode *iter = newHead;
        while(head != NULL){
            if(head->next != NULL){
                if(m_map.find(head->next) != m_map.end()){
                    iter->next = m_map[head->next];
                }
                else{
                    RandomListNode *newNode = new RandomListNode(head->next->label);
                    iter->next = newNode;
                    m_map[head->next] = newNode;
                }
            }
            if(head->random != NULL){
                if(m_map.find(head->random) != m_map.end()){
                    iter->random = m_map[head->random];
                }
                else{
                    RandomListNode *newNode = new RandomListNode(head->random->label);
                    iter->random = newNode;
                    m_map[head->random] = newNode;
                }
            }
            head = head->next;
            iter = iter->next;
        }
        return newHead;
    }
};

Smart way:

/**
 * Definition for singly-linked list with a random pointer.
 * struct RandomListNode {
 *     int label;
 *     RandomListNode *next, *random;
 *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
 * };
 */
class Solution {
public:
    RandomListNode *copyRandomList(RandomListNode *head) {
        if(head == NULL){
            return NULL;
        }
        RandomListNode *newHead;
        RandomListNode *iter = head;
        while(iter != NULL){
            RandomListNode *next = iter->next;
            RandomListNode *newNode = new RandomListNode(iter->label);
            iter->next = newNode;
            newNode->next = next;
            iter = next;
        }
        iter = head;
        newHead = head->next;
        while(iter != NULL && iter->next != NULL){
            if(iter->random != NULL){
                iter->next->random = iter->random->next;
            }
            iter = iter->next->next;;
        }
        iter = head;
        while(iter != NULL && iter->next != NULL){
            RandomListNode *next = iter->next;
            iter->next = next->next;
            iter = next;
        }
        return newHead;
    }
};