复杂链表类的拷贝构造函数的实现(1)

最新推荐文章于 2022-10-14 18:36:16 发布
最新推荐文章于 2022-10-14 18:36:16 发布
阅读量3.8k 收藏 3
点赞数 2
文章标签： 复杂链表的拷贝构造函 单链表 class random
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flrsun/article/details/51175736
版权 
复杂链表即就是在普通单链表的基础之上添加了一个可以指向链表中任意节点或者NULL的_random指针。
节点定义：

template <class T>
struct ComplexListNode{
    ComplexListNode(const T& d)
    :_data(d),_next(NULL),_random(NULL)
    {}
    T _data;
    ComplexListNode<T>* _next;
    ComplexListNode<T>* _random;
};
图1是一个含有5各节点的复杂链表。图中实箭头表示_next指针，虚箭头表示 _random指针.(NULL指针省略没有画出)

复杂链表示意图
构造函数和析构函数比较容易实现，这里不详细介绍直接贴出实现：
构造函数：

    ComplexList()
    :_head(NULL),_tail(NULL)
    {}
析构函数：

~ComplexList(){
    if (_head){
        ComplexListNode<T>* cur = _head;
        while (cur->_next != NULL){  //逐个删除节点
            ComplexListNode<T>* del = cur;
            cur = cur->_next;
            delete del;
        }
        delete cur;                  //删除_tail节点
        _head = _tail = NULL;
    }
    }
在实现其拷贝构造函数时，比较容易想到的做法就是讲整个拷贝过程分为两步：第一步就是复制原始链表的每一个节点，并用_next连接起来；第二步设置每一个节点的_random指针。假设原始链表中的节点N的_random指针指向S；则在复制后的的链表中设置N‘节点的_random指针时，需要从原始链表中定位到S节点所在的链表中的位置，需要添加一个计数器来统计其相对于头节点的位置。在确定了原始链表中S的位置，然后需要从头遍历赋值节点，找到相对应的S’；然后让_random指针指向S‘。这样一来虽然问题解决了。
对于一个有n个节点的链表来说，由于定位每个节点的_random都需要从链表的头节点开始遍历经过O(n)步定位到。因此这种方法的时间复杂度为O(n^2)。
分析上面的这种做法，大量的时间都发正在_random的定位上面。做进一步的优化。
这种方法主要分为三个步骤：
第一步：复制链表；
第二部：设置_random指针；
第三部：拆分。
下面详细介绍每一步的具体做法。
第一步、依然是复制链表，但是试讲复制的节点N’直接连接到N后面

复制第一步
实现代码：

void DoubleComplexList(ComplexList<T>& cp){
    ComplexListNode<T>* cur = cp._head;
    while (cur){
        ComplexListNode<T>* NewNode = 
        new ComplexListNode<T>(cur->_data);  //创建新节点；
        NewNode->_next = cur->_next;         
        cur->_next = NewNode;                //连接到基节点后；
        cur = cur->_next->_next;             
    }
}
第二步、设定每一个节点的_random指针；假设基链表上的N节点的_random指针指向S，那么复制出来的N‘是N的_naxt指向的节点；同样S’是S的_next指向的。如下图：

复制第二部
实现代码： 

void CopyRandom(ComplexList<T>& cp){
    if (cp._head){
        ComplexListNode<T>* cur = cp._head;
        while (cur){
            if (cur->_random != NULL){  //设置每一个节点的_random指针
                cur->_next->_random = cur->_random->_next;
            }
            cur = cur->_next->_next;
        }
    }
}
第三步、将第一步复制出来的链表拆分成为两个链表；用指针cur将基链表连接起来，使用cur1链表将复制链表连接起来。效果如下图所示：

复制第三步
实现代码：

void CopyComplexList(ComplexList<T>& cp){
    ComplexListNode<T>* cur = cp._head;    //控制cp链表的当前节点
    _head = cur->_next;
    cur->_next = cur->_next->_next;        //cur指向第二个节点，并且跳                    
    cur = cur->_next;                      //过新链表的头节点
    ComplexListNode<T>* cur2 = _head;      //控制新链表的当前结节点
    while (cur != cp._tail){
        cur2->_next = cur->_next;          //连接新链表
        cur2 = cur2->_next;                //cur指向新节点
        cur->_next = cur->_next->_next;    //连接cp链表
        cur = cur->_next;                  //移动至下一节点
    }
    cur2->_next = cp._tail->_next;
    cp._tail->_next = NULL;
    _tail = cur2->_next;
    _tail->_next = NULL;
}
将上面三个步骤合起来就实现了这个算法：

    ComplexList(ComplexList<T>& cp){
        DoubleComplexList(cp);  //复制节点，子节点连接在父节点之后；
        CopyRandom(cp);         //复制_random;
        CopyComplexList(cp);    //拆分cp链表，获得新链表；
    }

完整的复杂链表类的实现代码：

template <class T>
struct ComplexListNode{
    ComplexListNode(const T& d)
    :_data(d),_next(NULL),_random(NULL)
    {}
    T _data;
    ComplexListNode<T>* _next;
    ComplexListNode<T>* _random;
};

template <class T>
class ComplexList{
public:
    ComplexList()
    :_head(NULL),_tail(NULL)
    {}
    ComplexList(ComplexList<T>& cp){
        DoubleComplexList(cp);  //复制节点，子节点连接在父节点之后；
        CopyRandom(cp);         //复制_random;
        CopyComplexList(cp);    //拆分cp链表，获得新链表；
    }
    ~ComplexList(){
        if (_head){
            ComplexListNode<T>* cur = _head;
            while (cur->_next != NULL){
                ComplexListNode<T>* del = cur;
                cur = cur->_next;
                delete del;
            }
            delete cur;
            _head = _tail = NULL;
        }
    }
    void PushBack(const T& d){
        if (_head == NULL){
            _head = _tail = new ComplexListNode<T>(d);
        }
        else{
            _tail->_next = new ComplexListNode<T>(d);
            _tail = _tail->_next;
        }
    }
    void PopBack(){
        if (_head != _tail){
            ComplexListNode<T>* cur = _head;
            while (cur->_next != _tail){
                cur = cur->_next;
            }
            delete _tail;
            _tail = cur;
            _tail->_next = NULL;
        }
        else if (_head == _tail){
            delete _head;
            _head = _tail = NULL;
        }
    }
    ComplexListNode<T>* GetComplexListNode(const T& d){
        if (_head){
            ComplexListNode<T>* cur = _head;
            {
                while (cur->_data != d){
                    cur = cur->_next;
                }
            }
            return cur;
        }
    }
protected:
    void DoubleComplexList(ComplexList<T>& cp){
        ComplexListNode<T>* cur = cp._head;
        while (cur){
            ComplexListNode<T>* NewNode = new ComplexListNode<T>(cur->_data);
            NewNode->_next = cur->_next;
            cur->_next = NewNode;
            cur = cur->_next->_next;
        }
    }
    void CopyRandom(ComplexList<T>& cp){
        if (cp._head){
            ComplexListNode<T>* cur = cp._head;
            while (cur){
                if (cur->_random != NULL){
                    cur->_next->_random = cur->_random->_next;
                }
                cur = cur->_next->_next;
            }
        }
    }
    void CopyComplexList(ComplexList<T>& cp){
        ComplexListNode<T>* cur = cp._head;    //控制cp链表的当前节点
        _head = cur->_next;
        cur->_next = cur->_next->_next;        //cur指向第二个节点，并且跳过新链表的头节点
        cur = cur->_next;
        ComplexListNode<T>* cur2 = _head;      //控制新链表的当前结节点
        while (cur != cp._tail){
            cur2->_next = cur->_next;          //连接新链表
            cur2 = cur2->_next;                //cur指向新节点
            cur->_next = cur->_next->_next;    //连接cp链表
            cur = cur->_next;                  //移动至下一节点
        }
        cur2->_next = cp._tail->_next;
        cp._tail->_next = NULL;
        _tail = cur2->_next;
        _tail->_next = NULL;
    }
protected:
    ComplexListNode<T>* _head;
    ComplexListNode<T>* _tail;
};

测试用例：

void test(){
    ComplexList<int> a;
    a.PushBack(1);
    a.PushBack(2);
    a.PushBack(3);
    a.PushBack(4);
    a.PushBack(5);
    a.PushBack(6);
    a.PushBack(7);  
    ComplexListNode<int>* r1 = a.GetComplexListNode(2);
    ComplexListNode<int>* r2 = a.GetComplexListNode(5);
    r1->_random = r2;   //创建复杂链表

    ComplexList<int> s(a); //测试拷贝构造函数功能正确性
}

基链表结果：
基链表结果
复制链表的结果：
复制链表的结果

flrsun
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表分配指针 复制构造函数 node node->next=new
LLJ_DS的博客
07-11 1448
本篇文章记录博主在学习链表时、编写复制构造函数中、为复制目标（新目标）分配内存时出现的问题。 先看一下赋值构造函数完成的方式，图一为原链表，要根据原链表为新链表一一动态分配内存，并赋值，赋值结束条件为原链表节点指针==NULL。 我出错的代码： chainNode* sourceNode = list.firstNode; chainNode* targetNode = new c
单链表的拷贝
WGS.
12-30 3015
#include <iostream> #include <iomanip> #include <string.h> #include <cmath> #include <algorithm>//算法头文件 #include <fstream> #include <cstdlib> #include <vec...
链表复制函数c语言,梓益C语言学习笔记之常用链表操作函数
weixin_29507477的博客
05-20 478
梓益C语言学习笔记之常用链表操作函数一、创建链表void link_creat_head(STU **p_head,STU *p_new){STU *p_mov=*p_head;if(*p_head==NULL)//当第一次加入链表为空时，head执行p_new{*p_head=p_new;p_new->next=NULL;}else//第二次及以后加入链表{while(p_mov->...
顺序表和链表拷贝构造
weixin_43374319的博客
11-04 384
简单一部 #include &lt;iostream&gt; #define DATA int class SXB { int size; int len; DATA* p; public: SXB(const SXB&amp; that) // 拷贝构造 { size = that.size; len = that.len; p = new DATA[size]; f...
复制构造函数
12-02
对复制构造函数讲的很好 包括深度复制 、浅复制等
C++作业（复数类、链表类）1
08-04
总的来说，这个C++作业旨在让学生掌握面向对象编程的基本概念，包括类的设计、构造函数、拷贝构造函数、成员函数的实现、运算符重载，以及可能的链表操作。这些知识对于理解和编写复杂的C++程序至关重要。
C++链表倒序实现方法
09-04
由于我们不希望在类外复制节点，所以我们声明但不实现拷贝构造函数。 接着，`MyList`类包含了如下方法： 1. `addNode(Node* pNode)`：向链表尾部添加新节点。 2. `show(void) const`：打印链表中的所有节点数据。 3...
双向链表的C++实现
11-01
在本主题中，我们将深入探讨如何用C++实现双向链表，并关注描述中提到的特定功能：拷贝构造函数、输入/输出（IO）操作符重载和赋值操作符重载。 首先，我们来看`DoubleList.h`头文件，其中定义了双向链表类的接口。...
一元多项式 c++链表实现
05-07
// 构造函数、析构函数、拷贝构造函数和赋值运算符 Polynomial() : head(nullptr) {} ~Polynomial(); Polynomial(const Polynomial& other); Polynomial& operator=(const Polynomial& other); // 插入项 ...
关于链表类的拷贝构造函数与析构函数
guess_who_you_are的专栏
05-19 8377
链表类的拷贝构造函数需要把整个链表复制一遍！ (有借鉴网友们的文章） CMyLinkList::CMyLinkList(const CMyLinkList & aList) {     //cout     m_pHeader = new Node();     m_pHeader->next = NULL;     Node* ptr1 = m_pHeader;     N
图解复杂链表的拷贝
belongHWL的博客
09-14 148
描述：给定一个链表，每个节点包含一个额外增加的随机指针，该指针可以指向链表中的任何节点或空节点。 要求返回这个链表的深度拷贝。、 函数代码： 头文件： #ifndef _PLIST_H_ #define _PLIST_H_ #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h>...
【数据结构】复杂链表深度拷贝
dai_wen的博客
08-25 649
一、复杂链表深度拷贝 【1】题目： 已知一个复杂链表，该链表除了有一个指向下一个节点的指针外，还有一个指向任意节点的指针， 求： 设计一种方法，拷贝构造该链表 【2】算法思路： 1、使用一个map，将链表的地址映射成一个整数，即给链表的每个节点编号 2、使用一个vector，将新链表中的节点按照map中的指向指好 【3...
C语言：复制线性链表（递归）算法
最新发布
零小唬的博客
10-14 411
复制线性链表（递归）算法
经典链表拷贝算法
qq_43519428的博客
12-16 2359
问题描述： rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null,给定一个由Node节点组成的无环单链表的头节点head,实现链表的复制，并返回新链表的头节点。 时间复杂度O（N),额外空间复杂度O（1） 链表结构： class Node { public: Node* next=NULL; Node* rand=NULL; int value; Node(int _value) { this->valu
string 类,构造器,浅拷贝与深拷贝,拷贝链表
周杰伦
08-09 405
拷贝构造函数：对象的复制（调用拷贝构造函数） 类名(类名&amp;); 注：如果用户不显示的定义拷贝构造，编译器会默认添加拷贝构造 浅 深 对象的生命周期： 1、分配空间：数据区（动态区，静态区，堆区） 动态区：在函数内实例化的（非staic...
【数据结构】【C语言】链表相关函数
weixin_42302504的博客
06-01 689
typedef struct nNode Node; struct nNode { // 向上指针 Node* nUp; // 向下指针 Node* nDown; // 字符串字节数 int iSize; // 字符串指针 char* acStr; }; typedef struct { Node* nTop; Node* nBottom; int iSize; } Li...
C++ 运算符重载和拷贝构造(二)
一首小夜曲
08-01 205
在运算符重载的过程中，如果是二元的运算符（+,-,*,/,etc)，那么成员函数需要有一个参数。如下代码：#include "stdafx.h" #include <iostream> using namespace std;class Integer { public: Integer(int n) :i(n) { cout << "Integer::Integer(int)"<<i <<
C++复制构造函数以及赋值运算符重载
夏洛克福尔摩斯
12-08 260
//statement.h #ifndef STATEMENT_H_ #define STATEMENT_H_ #include&lt;iostream&gt; using std::cout; using std::cin; using std::ostream; using std::istream; class String { private: char *str; int len;...
数据结构之线性表—链表描述
whhcs的博客
09-05 445
@TOC 线性表—链式描述 在基于数组的描述中，元素的地址是由数学公式决定的，分布在一段连续的内存空间中。 在链式描述中，线性表的元素在内存中的存储位置是随机的。每个元素都有一个明确的指针或链指向线性表的下一个元素的地址 。   单向链表 设L = (e0e_0e0​, e1e_1e1​,…, en−1e_n-_1en​−1​) 是一个线性表，在这个线性表中，每个元素都在一个单独的节点中描述，每一个节点都有一个链域，它的值是线性表的下一个元素的地址。所以，元素eie_iei​的节点链接着元素ei+
C++笔试必备：链表反转与String类实现解析
"这篇资料是关于C++笔试题目的汇总，包含了链表反转等常见问题。对于准备C++笔试或面试...以上是针对链表反转的两种方法和`String`类的成员函数实现的基本思路。理解并掌握这些内容对于理解和解答C++笔试题目至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值