list的模拟实现

最新推荐文章于 2024-07-14 16:41:07 发布
最新推荐文章于 2024-07-14 16:41:07 发布
阅读量351 收藏 23
点赞数 25
分类专栏： C++ 文章标签： list c++ visual studio windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Snow_Dragon_L/article/details/133975178
版权

list的模拟实现

一、节点类

1、代码

template<class T>
struct ListNode
{
    ListNode(const T& val = T())
        :_val(val)
        ,_pPre(nullptr)
        ,_pNext(nullptr)
    {}
    ListNode<T>* _pPre;
    ListNode<T>* _pNext;
    T _val;
};

2、实现原理

  • 因为这里模拟实现的是带头双向链表，所以定义两个类类型的指针_pPre和_pNext，用来指向节点的前一个和后一个节点，用_val存储数据。
  • 为了方便开辟空间和初始化节点，需要实现一个无参的构造函数，而构造出来的节点的前后节点我们是不知道的，所以都置为空即可。
  • 因为节点类的成员变量与成员函数在节点类外需要用到，所以定义类时使用struct而不用class，因为struct的默认限定符是public。

3、注意

  • 构造函数的形参val的缺省值需用T()，如果传入的val需要的是自定义类型时，编译器会直接调用它的构造函数去构造变量。

二、迭代器类

1、基本框架

（1）代码

template<class T, class Ref, class Ptr>
class ListIterator
{
    typedef ListNode<T>* PNode;
    typedef ListIterator<T, Ref, Ptr> Self;
public:
	PNode _pNode;

（2）实现原理

  • 因为迭代器类中的其他函数要使用到引用和指针，所以模板参数需要有三个，第一个为类型，第二个为类型的引用，第三个为类型的指针。
  • 因为在迭代器类外可能需要使用到本节点的指针变量，所以_pNode需用public限定符限定。
  • 因为迭代器类中的内容都是要对外开放的，所以定义类时可以使用struct而不是class，因为class默认的限定符是private，而struct的默认限定符是public。

2、*运算符重载

（1）代码

Ref operator*()
{
    return _pNode->_val;
}

（2）作用

  • 当我们用迭代器时，需要对迭代器进行解引用进而获得它所指向的数据，例如*it（it为迭代器变量）就可以获得它所指向的数据。

（3）注意

  • 返回值需为_pNode->_val而不能是_pNode，因为_pNode只是一个指针而不是数据，链表的数据存储在节点的成员变量_val中。

3、->运算符重载

（1）代码

Ptr operator->()
{
    return &_pNode->_val;
}

（2）作用

  • 当链表的元素是一个自定义类型，并且它的内部有成员变量而我们想访问它时，就需要使用到->，如果迭代器中没有重载->运算符，访问时只能是先对迭代器进行解引用再访问成员变量，即(*it)->成员变量名，这样操作会显得比较麻烦。
  • 当重载了->运算符时，就可以直接访问成员变量，即it->成员变量名。

（3）注意

  • 返回的是_val，而不是指针_pNode。
  • 虽然写代码时是写成it->成员变量名，但编译器实际调用时是省略了一个->，即实际代码是it.operator->()->成员变量名。

4、自增与自减运算符重载

（1）代码

Self& operator++()
{
    _pNode = _pNode->_pNext;
    return *this;
}
Self operator++(int)
{
    Self tmp(*this);
    _pNode = _pNode->_pNext;
    return tmp;
}

Self& operator--()
{
    _pNode = _pNode->_pPre;
    return *this;
}
Self operator--(int)
{
    Self tmp(*this);
    _pNode = _pNode->_pPre;
    return tmp;
}

（2）实现原理

  • 自增运算符分为前置自增和后置自增，前置自增返回自增完的变量，而后置自增需要返回自增前的变量值，再将变量自增。
  • 所以前置自增只需将节点移动到下一个节点处，在返回本对象即可。
  • 后置自增需要先构造一个对象，保存自增前的节点，再将本对象的_pNode移动到下一个节点处，最后返回保存自增前的节点的对象。
  • 后置自增需要加一个占位符作为形参，作为前置自增和后置自增的区分。
  • 自减和自增类似，这里不再过多说明。

（3）注意

  • 自增和自减的返回类型为Self，即ListIterator<T, Ref, Ptr>，即需要返回本类的对象。
  • 后置自增与自减的返回类型不能加引用，要使用值传递的方式。因为tmp是在该函数的内部创建的，出了作用域将会调用析构函数进行析构。

5、判断运算符重载

（1）代码

bool operator!=(const Self& l)
{
    return _pNode != l._pNode;
}
bool operator==(const Self& l)
{
    return _pNode == l._pNode;
}

（2）实现原理

  • 判断两个迭代器对象是否相等，本质上就是判断它们指向的_pNode是否是同一个。
  • 因为只是进行判断不做修改，所以形参采用引用和用const修饰，减少拷贝，使代码的效率更高。

三、list类

1、基本框架

（1）代码

template<class T>
class list
{
    typedef ListNode<T> Node;
    typedef Node* PNode;
    typedef ListIterator<T, T&, T*> iterator;
    typedef ListIterator<T, const T&, const T*> const_iterator;
private:
    void CreateHead()
    {
        _pHead = new Node;
        _pHead->_pPre = _pHead;
        _pHead->_pNext = _pHead;
    }
    PNode _pHead;
};

（2）实现原理

  • 使用typedef 将一些类型进行重定义，方便下方的代码书写。
  • 迭代器的对象可能被const修饰，这时，它将无法调用没被const修饰的迭代器的函数，解决这个问题的方法可以是重载一个迭代器类，但重载的迭代器类和原先的迭代器模板类的函数只有返回类型不同，其他的都一样，这样就会显得代码很冗余。所以，使用模板的三个参数就可以解决这个问题，只不过传的实参不同而已。
  • 由于此处实现的链表是一个带头的循环链表，所以需要一个头节点，则定义_pHead作为头节点并用private限定符限定起来，因为在list类的外部无需使用到它。
  • 实现一个CreateHead函数，使它具有创建头节点的功能，这样在其他函数中要创建头节点时只需要调用这个函数即可。其次，这个函数可以用private限定符限定起来，因为在list类的外部无需使用到它。

（3）注意

  • 为了具有被const修饰的迭代器的类，需要用模板参数的方法或者重载一个迭代器类。而不能在list类内部使用const iterator实现，因为此处的const是修饰迭代器本身，即迭代器本身不能修改，而它指向的内容可以修改，即迭代器的自增与自减等等操作将无法使用。

2、insert函数

（1）代码

iterator insert(iterator pos, const T& val)
{
    /*PNode newNode = new Node;
    newNode->_val = val;*/

    PNode newNode = new Node(val);

    PNode posNode = pos._pNode;
    PNode prev = posNode->_pPre;
    newNode->_pNext = posNode;
    newNode->_pPre = prev;
    posNode->_pPre = newNode;
    prev->_pNext = newNode;

    return iterator(newNode);
}

（2）实现原理

  • 因为insert函数的作用是在pos位置前插入值为val的节点，所以，首先应该创建一个节点。因为ListNode类中有构造函数，所以，直接用val构造一个节点即可。当然，可以自己创建节点并赋值为val，即代码中被注释的部分。
  • 因为是插入节点，即需要在pos和pos的前一个节点之间插入一个节点。所以，对pos和pos的前一个节点的_pPre 和_pNext 进行修改即可，最后再返回新插入的节点的迭代器即可。

（3）注意

  • 因为返回类型是iterator ，即迭代器。所以，不能直接返回新创建出来的节点，即newNode，需要用newNode作为实参去创建一个迭代器，再将这个迭代器返回。

3、erase函数

（1）代码

iterator erase(iterator pos)
{
    assert(pos != end());
    PNode prev = pos._pNode->_pPre;
    PNode next = pos._pNode->_pNext;
    prev->_pNext = next;
    next->_pPre = prev;
    delete pos._pNode;

    return iterator(next);
}

（2）实现原理

  • 因为erase是删除存有数据的链表节点，而头节点不属于这个范畴，所以，使用assert对pos进行断言，当删除的位置是头节点时，直接进行报错而不进行下面的操作。
  • 因为是删除pos节点，所以，需要对pos的前一个节点和后一个节点进行处理，即对节点的_pPre 和_pNext 进行修改。
  • 然后再释放掉pos节点的空间，最后再返回用下一个节点作为实参创建出来的迭代器。

4、迭代器函数

（1）代码

iterator begin()
{
    return iterator(_pHead->_pNext);
}
iterator end()
{
    return iterator(_pHead);
}

const_iterator begin() const
{
    return const_iterator(_pHead->_pNext);
}
const_iterator end() const
{
    return const_iterator(_pHead);
}

（2）实现原理

  • 因为有头节点的存在，所以头节点的下一个节点就是存储数据的链表节点中的第一个节点，头节点的位置就是存储数据的链表节点中的最后一个节点的下一个节点。所以，各函数就返回对应节点的迭代器即可。
  • 为了让被const修饰的链表对象也能调用对应的函数，所以需要重载对应的函数，即重载this指针被const修饰，返回类型也被const修饰的函数。

（3）注意

  • 因为返回类型是迭代器，所以返回的不能是节点本身，即_pHead->_pNext和_pHead，而是要用该节点去构造一个迭代器对象，再将这个迭代器对象作为返回值返回。

5、clear函数和析构函数

（1）代码

void clear()
{
    iterator it = begin();
    while (it != end())
    {
        //it = erase(it);
        erase(it++);
    }

    _pHead->_pPre = _pHead;
    _pHead->_pNext = _pHead;
}

~list()
{
    clear();
    delete _pHead;
    _pHead = nullptr;
}

（2）实现原理

  • 因为clear函数是清理链表的元素，对头节点不做处理。所以，使用迭代器的方法遍历链表并释放它们的空间。对迭代器的自增可以在调用erase函数后更新迭代器it的值，因为erase函数返回的是被删除节点的下一个节点，即代码中被注释的部分；也可以在调用erase函数时，使用后置自增的方法，即传入的实参是没自增之前的迭代器，在这个时候erase函数还没调用，但迭代器it已经完成了自增。
  • 因为clear函数不对头节点做处理，所以在最后需要对头节点_pHead的前后指针进行修改，不然它指向的空间已经被释放，而对它们进行访问将是非法的操作。
  • 因为clear函数可以清理链表的元素，所以，析构函数可以复用clear函数，然后再对头节点的空间进行释放即可。最后，为了安全，可以将头节点置为空。

6、swap函数、构造函数、拷贝构造函数和赋值运算符重载

（1）代码

void swap(list<T>& l)
{
    ::swap(_pHead, l._pHead);
}

template <class Iterator>
list(Iterator first, Iterator last)
{
    CreateHead();
    while (first != last)
    {
        push_back(*first++);
    }
}
list(const list<T>& l)
{
    CreateHead();
    list<T> tmp(l.begin(), l.end());
    swap(tmp);
}

list<T>& operator=(list<T> l)
{
    swap(l);
    return *this;
}

（2）实现原理

  • 因为链表头节点的作用是访问其他节点，所以，交换两个链表只需交换它们的头节点即可。
  • 迭代器方式的构造函数只需用迭代器遍历链表并将对应的元素尾插在本链表里即可，而尾插函数实际上就是复用insert函数在end()位置进行插入元素操作的函数。
  • 因为有了迭代器方式的构造函数，所以拷贝构造函数可以直接复用它，最后再将本链表和构造出来的链表tmp进行交换即可。
  • 赋值运算符重载函数可以采用形参传值拷贝的方式， 即形参是拷贝出来的链表，此时，再将本链表和形参链表进行交换即可。

四、模拟实现list的代码

#pragma once

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

namespace snow
{
    //List的节点类
    template<class T>
    struct ListNode
    {
        ListNode(const T& val = T())
            :_val(val)
            ,_pPre(nullptr)
            ,_pNext(nullptr)
        {}
        ListNode<T>* _pPre;
        ListNode<T>* _pNext;
        T _val;
    };


    //List的迭代器类
    template<class T, class Ref, class Ptr>
    class ListIterator
    {
        typedef ListNode<T>* PNode;
        typedef ListIterator<T, Ref, Ptr> Self;
    public:
        ListIterator(PNode pNode = nullptr)
            :_pNode(pNode)
        {}

        Ref operator*()
        {
            return _pNode->_val;
        }
        Ptr operator->()
        {
            return &_pNode->_val;
        }
        Self& operator++()
        {
            _pNode = _pNode->_pNext;
            return *this;
        }
        Self operator++(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pNext;
            return tmp;
        }
        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }
        Self operator--(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pPre;
            return tmp;
        }
        bool operator!=(const Self& l)
        {
            return _pNode != l._pNode;
        }
        bool operator==(const Self& l)
        {
            return _pNode == l._pNode;
        }
        PNode _pNode;
    };


    //list类
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T*> const_iterator;
    public:
        list()
        {
            CreateHead();
        }
        list(int n, const T& value = T())
        {
            CreateHead();
            for (size_t i = 0; i < n; ++i)
            {
                push_back(value);
            }
        }
        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            CreateHead();
            while (first != last)
            {
                push_back(*first++);
            }
        }
        list(const list<T>& l)
        {
            CreateHead();
            list<T> tmp(l.begin(), l.end());
            swap(tmp);
        }
        list<T>& operator=(list<T> l)
        {
            swap(l);
            return *this;
        }
        ~list()
        {
            clear();
            delete _pHead;
            _pHead = nullptr;
        }
        
        iterator begin()
        {
            return iterator(_pHead->_pNext);
        }
        iterator end()
        {
            return iterator(_pHead);
        }
        const_iterator begin() const
        {
            return const_iterator(_pHead->_pNext);
        }
        const_iterator end() const
        {
            return const_iterator(_pHead);
        }
        
        size_t size()const
        {
            size_t size = 0;
            const_iterator start = begin();
            while (start != end())
            {
                ++size;
                ++start;
            }
            return size;
        }
        bool empty()const
        {
            return size() == 0;
        }

        T& front()
        {
            assert(!empty());
            return _pHead->_pNext->_val;
        }
        const T& front()const
        {
            assert(!empty());
            return _pHead->_pNext->_val;
        }
        T& back()
        {
            assert(!empty());
            return _pHead->_pPre->_val;

        }
        const T& back()const
        {
            assert(!empty());
            return _pHead->_pPre->_val;
        }

        void push_back(const T& val) 
        { 
            insert(end(), val); 
        }
        void pop_back() 
        { 
            erase(--end());
        }
        void push_front(const T& val) 
        { 
            insert(begin(), val); 
        }
        void pop_front() 
        { 
            erase(begin());
        }

        iterator insert(iterator pos, const T& val)
        {
            /*PNode newNode = new Node;
            newNode->_val = val;*/

            PNode newNode = new Node(val);

            PNode posNode = pos._pNode;
            PNode prev = posNode->_pPre;
            newNode->_pNext = posNode;
            newNode->_pPre = prev;
            posNode->_pPre = newNode;
            prev->_pNext = newNode;
            
            return iterator(newNode);
        }
        iterator erase(iterator pos)
        {
            assert(pos != end());

            PNode prev = pos._pNode->_pPre;
            PNode next = pos._pNode->_pNext;
            prev->_pNext = next;
            next->_pPre = prev;
            delete pos._pNode;

            return iterator(next);
        }
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                //it = erase(it);
                erase(it++);
            }

            _pHead->_pPre = _pHead;
            _pHead->_pNext = _pHead;
        }
        void swap(list<T>& l)
        {
            ::swap(_pHead, l._pHead);
        }
    private:
        void CreateHead()
        {
            _pHead = new Node;
            _pHead->_pPre = _pHead;
            _pHead->_pNext = _pHead;
        }
        PNode _pHead;
    };
};
  • 本文只是对list的一些常用与常见的函数模拟实现与讲解，一些比较简单的函数没有讲解但在上方的代码中都有模拟实现的代码。

本文到这里就结束了，如有错误或者不清楚的地方欢迎评论或者私信
创作不易，如果觉得博主写得不错，请务必点赞、收藏加关注💕💕💕

Snow_Dragon_L
关注
  • 25
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 22
    评论
专栏目录
list简单模拟实现
L_listen的博客
10-28 311
#define _CRT_SECURE_NO_WARNINGS #pragma once #include <assert.h> #include <iostream> using namespace std; template<class T> struct ListNode { ListNode(const T& data = T()) :_pPre(0) , _pNex
STL中list模拟实现源码
08-06
list模拟实现源码，适合初学者学习
【C++】list模拟实现
chuxinchangcun的博客
01-10 6232
由源码可以得知,list的底层是带头双向循环链表—list实际上是一个带头双向循环链表,要实现list,则首先需要实现一个结点类,而一个结点需要存储的信息为:数据、前驱指针、后继指针而对于该结点类的成员函数来说,我们只需实现一个构造函数即可,因为该结点类只需要根据数据来构造一个结点即可,而结点的释放则由list的析构函数来完成, 构造函数 构造函数直接根据所给数据构造一个结点即可,构造出来的结点的数据域存储的就是所给数据,而前驱指针和后继指针均初始化为空指针即可 若构造结点时未传入数据,则默认以list
C++ [STL之list模拟实现]
ARMCSKGT的博客
06-15 6397
list的底层与vector和string不同，实现也有所差别，特别是在迭代器的设计上，本节将为大家介绍list简单实现，并揭开list迭代器的底层！list模拟实现到这里就介绍了，本篇我们简单介绍了一下list的增删功能实现(与链表差别不大)，重点介绍了list的迭代器思想，深入理解list的迭代器可以让我们对类和对象又有进一步的认识，如果我们可以理解list迭代器思想，那么list的其他函数对于我们来说都不成问题！
【C++】STL——list模拟实现
M的博客
06-25 942
list的模拟实现，主要对list正向迭代器与反向迭代器进行阐述，详细解析
C++模拟实现list
03-11
C++模拟实现list
List各个接口模拟实现
08-27
List各个接口模拟实现
C++ 模拟实现list(迭代器)实现代码
08-30
C++ 模拟实现 List（迭代器）实现代码 C++ 模拟实现 List（迭代器）是指使用 C++ 语言来模拟实现 List 数据结构，并提供迭代器来遍历 List 中的元素。在本文中，我们将介绍如何使用 C++ 语言来模拟实现 List（迭代...
Java数据结构-链表与LinkedList
daweidi的博客
07-11 1709
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。LinkedList实现了List接口。LinkedList没有实现RandomAccess接口，因此不支持随机访问。LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O（1）方法解释尾插 e将 e 插入到 index 位置尾插 c 中的元素删除 index 位置元素。
[NeetCode 150] Merge K Sorted Linked Lists
ShadyPi的IT笔记
07-13 764
【代码】[NeetCode 150] Merge K Sorted Linked Lists。
ArrayList和LinkedList的区别
最新发布
2401_84909321的博客
07-14 191
然而，随着大数据和分布式系统的兴起，对于集合操作的性能和内存效率的要求越来越高。在某些特定场景下，如需要频繁进行大量数据的插入和删除操作，且对随机访问的需求不高时，接口的实现，用于存储一系列的元素，但它们的内部实现机制和性能特性却大相径庭。然而，在列表的开头或中间位置插入或删除元素时，由于需要移动元素，其时间复杂度为O(n)。在添加和删除元素时非常高效，尤其是当操作发生在列表的开头或结尾时，时间复杂度为O(1)。中添加元素时，如果当前数组的容量不足以容纳新元素，则会自动扩容，通常是扩容至原来的1.5倍。
【C++】 List 基本使用
Long_kin的博客
07-12 883
List基本使用深度解析
前端视角下的Spring-Boot语法学习：demo-todo-list 实现数据库增删改查
weixin_45368328的博客
07-12 635
1、Lombok用来生成实体类 Getter 和 Setter 架包不使用 Lombok 的情况使用 Lombok总结： 简化代码Spring Web 提供了强大的 Web MVC 框架，用于构建灵活和可扩展的 Web 应用程序简单点理解就是专门做 web 端接口开发，提供了很多注解，目前常用的注解有：总结：还有很多并没有列举出来，但是只是知道 Spring Web 是干什么的，也可以理解为前端的 Vue是一个优秀的持久层框架，它确实支持自定义 SQL、存储过程以及高级映射。
[C++] 模拟实现list（二）
水墨不写bug
07-11 1100
C++模拟实现STL的list，原理和实现思路详解
[leetcode]partition-list 分隔链表
xiaocong1990的博客
07-10 391
【代码】[leetcode]partition-list 分隔链表。
Linux内核 -- 内存管理之scatterlist结构使用
sz66cm 学习随笔
07-09 602
结构在 Linux 内核中主要用于 DMA（直接内存访问）操作中的内存管理。它允许将不连续的物理内存片段表示为一个逻辑上的连续块，从而使 DMA 操作可以高效地处理这些不连续的内存片段。
ant design form动态增减表单项Form.List如何进行动态校验规则
u010234868的专栏
07-12 208
在使用ant design form动态增减表单项Form.List时，Form.List中有多组表单项，一组中的最后一个表单项的校验规则是动态的，该组为最后一组时，最后一个表单项是非必填项，其他时候为必填项。假设动态增加了两组表单项，均为填写内容，在必填项校验被触发后，删除了第二组表单项，此时仅剩一组表单项，想要最后一个表单项的校验状态不再显示必填项提示。等相关代码，将规则校验放在删除表单组的操作中。使用动态校验规则，获取到最后一组的索引，使用form.validateFields重新触发校验规则。
Java List不同实现类的对比
qq_35899077的博客
07-12 366
ArrayList 是 List 接口的本质上，ArrayList是对象引用的一个”变长”数组Arrays.asList(…) 方法返回的 List 集合，既不是 ArrayList 实例，也不是 Vector 实例。 Arrays.asList(…) 返回值是一个固定长度的 List 集合对于频繁的插入或删除元素的操作，建议使用LinkedList类，效率较高。这是由底层采用链表（双向链表）结构存储数据决定的。特有方法：
c++模拟实现vector
09-01
总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值