list模拟实现C++

最新推荐文章于 2024-08-10 23:26:07 发布
最新推荐文章于 2024-08-10 23:26:07 发布
阅读量22 收藏
点赞数
文章标签： list c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74081037/article/details/132542867
版权

1.list介绍

2.默认成员函数

3.迭代器

4.增删查改

1.list介绍

       list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。

2.默认成员函数

        typedef ListNode<T> Node;
        typedef Node* PNode;
    private:
        Node* head;
    public:
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T&> const_iterator;
    public:
        ///
        // List的构造
        void Initlist()
        {
            head = new Node;
            head->_pNext = head;
            head->_pPre = head;
            head->_val = 0;
        }

        list()
        {
            Initlist();
        }
        list(int n, const T& value = T())
        {
            Initlist();
            for (int i = 0; i < n; ++i)
                push_back(value);

        }
        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            Initlist();
            while (first != last)
            {
                push_back(*first);
                first++;
            }
        }
        list(const list<T>& l)
        {
            Initlist();
            for (auto e : l)
            {
                push_back(e);
            }
        }
        list<T>& operator=(const list<T> l)
        {
            for (auto it:l)
            {
                push_back(it);
            }
            return *this;
        }
        ~list()
        {
            clear();
            delete head;
            head = nullptr;
        }

3.迭代器

a.begin+end：返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器。

b.rbegin+rend：返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的 reverse_iterator,即begin位置。

迭代器失效：迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代 器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

class ListIterator
    {
        typedef ListNode<T>* PNode;
        typedef ListIterator<T, Ref, Ptr> Self;
    public:
        ListIterator(PNode pNode = nullptr)
            :_pNode(pNode)
        {}
        ListIterator(const Self& l)
        {
            _pNode = l._pNode;
        }
        T& operator*()
        {
            return _pNode->_val;
        }
        T* 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;
        }
    private:
        PNode _pNode;
    };
///
        // List Iterator
        iterator begin()
        {
            return head->_pNext;
        }
        iterator end()
        {
            return head;
        }
        const_iterator begin()
        {
            return head->_pNext;
        }
        const_iterator end()
        {
            return head;
        }

5.增删查改

a.empty：检测list是否为空，是返回true，否则返回false。

b.size：返回list中有效节点的个数。

c.front：返回list的第一个节点中值的引用。

d.back：返回list的最后一个节点中值的引用。

e.push_front：在list首元素前插入值为val的元素。

f.pop_back：删除list中第一个元素。

g.push_back:：在list尾部插入值为val的元素。

h.pop_back： 删除list中最后一个元素。

i.insert： 在list position 位置中插入值为val的元素。

j.erase： 删除list position位置的元素。

k.swap： 交换两个list中的元素。

l.clear： 清空list中的有效元素。

///
        // List Capacity
        size_t size()const
        {
            size_t i = 0;
            auto it = begin();
            while (it!= end())
            {
                i++;
                it++;
            }
        }
        bool empty()const
        {
            return size() == 0;
        }


        
        // List 


        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;
        }

        
        // List Modify
        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()); }
        // 在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            Node* newnode = new Node(val);
            Node* cur = pos._pNode;
            cur->_pPre->_pNext = newnode;
            newnode->_pPre = cur->_pPre;
            newnode->_pNext = cur;
            cur->_pPre = newnode;
            return (iterator)newnode;
            //return newnode;
        }
        // 删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            Node* cur = pos._pNode;
            Node* next = cur->_next;
            cur->_pPre->_pNext = cur->_pNext;
            cur->_pNext->_pPre = cur->_pPre;
            delete cur;
            return  (iterator)next;
        }
        void clear()
        {
            auto it = begin();
            while (it != end())
            {
                erase(it);
            }
        }
        void swap(list<T>& l)
        {
            std::swap(head, l.head);
        }

完整代码如下：

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


    //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)
        {}
        ListIterator(const Self& l)
        {
            _pNode = l._pNode;
        }
        T& operator*()
        {
            return _pNode->_val;
        }
        T* 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;
        }
    private:
        PNode _pNode;
    };
    


    //list类
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
    private:
        Node* head;
    public:
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T&> const_iterator;
    public:
        ///
        // List的构造
        void Initlist()
        {
            head = new Node;
            head->_pNext = head;
            head->_pPre = head;
            head->_val = 0;
        }

        list()
        {
            Initlist();
        }
        list(int n, const T& value = T())
        {
            Initlist();
            for (int i = 0; i < n; ++i)
                push_back(value);

        }
        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            Initlist();
            while (first != last)
            {
                push_back(*first);
                first++;
            }
        }
        list(const list<T>& l)
        {
            Initlist();
            for (auto e : l)
            {
                push_back(e);
            }
        }
        list<T>& operator=(const list<T> l)
        {
            for (auto it:l)
            {
                push_back(it);
            }
            return *this;
        }
        ~list()
        {
            clear();
            delete head;
            head = nullptr;
        }


        ///
        // List Iterator
        iterator begin()
        {
            return head->_pNext;
        }
        iterator end()
        {
            return head;
        }
        const_iterator begin()
        {
            return head->_pNext;
        }
        const_iterator end()
        {
            return head;
        }


        ///
        // List Capacity
        size_t size()const
        {
            size_t i = 0;
            auto it = begin();
            while (it!= end())
            {
                i++;
                it++;
            }
        }
        bool empty()const
        {
            return size() == 0;
        }


        
        // List 


        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;
        }

        
        // List Modify
        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()); }
        // 在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            Node* newnode = new Node(val);
            Node* cur = pos._pNode;
            cur->_pPre->_pNext = newnode;
            newnode->_pPre = cur->_pPre;
            newnode->_pNext = cur;
            cur->_pPre = newnode;
            return (iterator)newnode;
            //return newnode;
        }
        // 删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            Node* cur = pos._pNode;
            Node* next = cur->_next;
            cur->_pPre->_pNext = cur->_pNext;
            cur->_pNext->_pPre = cur->_pPre;
            delete cur;
            return  (iterator)next;
        }
        void clear()
        {
            auto it = begin();
            while (it != end())
            {
                erase(it);
            }
        }
        void swap(list<T>& l)
        {
            std::swap(head, l.head);
        }
    private:
        PNode _pHead;
    };
};

Sakura＆NANA
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3179
简易版list模拟实现超详解
C++模拟实现list
03-11
C++模拟实现list
C++ list模拟实现
Han同学
12-25 3057
C++模拟实现list
【C++】List模拟实现
Renswc的博客
05-31 3093
C++中的list是一种双向链表（doubly linked list）的实现。它是C++标准库中的一种容器，可以存储一系列元素，并且允许在任意位置插入、删除和访问元素。对于双向链表有疑问的可以点击查看数据结构——带头双向循环链表详解对于list大部分和前面学习过的vector类似，关键点在于理解list的迭代器的封装以及const迭代器，还有list实现包括了三个类，它们分别都有类模板，容易绕晕，需要好好理解清楚
C++ —— 模拟实现list
weixin_59913110的博客
12-03 838
模拟实现了list容器的常用接口，初步认识模板的用法。
【爱上C++】list用法详解、模拟实现
2301_76677973的博客
07-22 2976
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
C++——list的使用及其模拟实现
Forward♞的博客
01-28 1553
作为标准模板库中的容器，list同样也是一个类模板如果要定义一个list对象，就需要指定其存储的数据类型T。list
【C++】list模拟实现
chuxinchangcun的博客
01-10 6247
由源码可以得知,list的底层是带头双向循环链表—list实际上是一个带头双向循环链表,要实现list,则首先需要实现一个结点类,而一个结点需要存储的信息为:数据、前驱指针、后继指针而对于该结点类的成员函数来说,我们只需实现一个构造函数即可,因为该结点类只需要根据数据来构造一个结点即可,而结点的释放则由list的析构函数来完成, 构造函数 构造函数直接根据所给数据构造一个结点即可,构造出来的结点的数据域存储的就是所给数据,而前驱指针和后继指针均初始化为空指针即可 若构造结点时未传入数据,则默认以list
【C++】list类模拟实现
qq_66314292的博客
11-09 1946
list类的模拟实现
【C++】list的模拟实现
dab112的博客
07-20 1406
list的模拟实现
【C++】list的模拟实现【完整理解版】
m0_74044018的博客
09-10 1130
list的模拟实现，主讲你不理解的地方，每个地方都会详细解释，重在理解
C++ 模拟实现list(迭代器)实现代码
08-30
C++ 模拟实现 List（迭代器）实现代码 C++ 模拟实现 List（迭代器）是指使用 C++ 语言来模拟实现 List 数据结构，并提供迭代器来遍历 List 中的元素。在本文中，我们将介绍如何使用 C++ 语言来模拟实现 List（迭代...
c++ vector模拟实现代码
12-20
下面我们将详细讨论`vector`的主要特点、内部实现原理以及模拟实现的代码解析。 1. **vector的基本特性** - `vector`是一个序列容器，它存储一序列相同类型的对象。 - 它的元素在内存中是连续存储的，因此可以...
c模拟c++ stl list
06-18
然而，为了在C语言中模拟`std::list`的功能，我们需要手动创建一个类似的结构并实现其核心操作。 以下是一个简化的C语言实现`std::list`的概述： 1. **数据结构**：首先，我们需要定义一个节点结构来存储数据以及...
C++ STL专题 list的讲解
Mike的博客
08-07 742
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
集合：（ArrayList）的插值和去重，包含（Iterator和listIterator）迭代器相关使用
最新发布
ABU009的博客
08-10 578
总结：去重用for循环，插值可用for循环和迭代器（可以方便在中间插值），如果要修改集合，就用listIterator，防止父类的Iterator没有add添加功能，也避免版本号不一致报错。我们按照需求编写代码，在遍历迭代器的时候，当遇到"java"，我们是使用集合中add方法进行添加元素的，运行的时候就报错了。//将原集合以及迭代器的版本号也设置成一样的了，所以将来再检查版本号的时候，原集合和迭代器的版本号是一致的。正确写法如下：基本数据类型（第一种是迭代器，第二种是for循环）
STL中的list以及简单实现
Small_entreprene的博客
08-07 821
说到迭代器遍历的话，与string，vector都一样；
Java Streams 对 List 操作的最佳实践
心猿意码
08-07 392
在Java 8中引入的Stream API允许我们以一种更加自然和高效的方式来处理集合。与传统的循环或迭代不同，Stream API允许我们通过管道式的方法来处理数据流。这些操作可以分为中间操作（如filter, map, distinct等）和终端操作（如collect, forEach, reduce等）。java深色版本510 }1113}
List＜HashMap＜String, Object＞＞排序
weixin_43735471的博客
08-07 313
List排序
c++模拟实现vector
09-01
- *1* *2* *3* [C++——vector模拟实现](https://blog.csdn.net/weixin_49449676/article/details/126813526)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Sakura＆NANA

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值