C++list的介绍和简单实现

已于 2024-01-29 17:48:06 修改
阅读量670 收藏 9
点赞数 28
文章标签： c++ 开发语言 list
于 2024-01-29 17:47:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74515566/article/details/135898163
版权
本文详细介绍了C++STL中的list容器，包括其作为双向链表的数据结构，支持在任意位置进行插入和删除的特点，以及常见的接口如迭代器的使用和模拟实现。还探讨了list与其他序列式容器的区别，以及list的复制、删除和析构方法。

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

1、list的介绍和使用

1.1   list介绍

list是一个双向带头循环链表

该容器非常适合在任意位置插入和删除，时间复杂度都是O(1)

与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问

 

1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)

 

1.2   list的常见的重要接口

构造函数

和vector构造差不多

其他的函数也一样

迭代器begin和end: 返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器

rbegin和rend:  返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置

cbegin、cend以及crbegin、crend在前面的基础上进行const修饰

empty 判断list是否为空

size 返回list中有效节点个数

front 返回list的第一个节点中值的引用

back 返回list的最后一个节点中值的引用

push_front 头插  pop_front 头删  push_back 尾插 pop_back尾删

insert 在pos位置插入一个值为val的元素

erase删除pos位置的元素

swap 交换两个list中的元素

clear 清除list中的有效元素

1.3   遍历方式

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

void Test()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	lt.push_back(5);
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << ' ';
		it++;
	}
	cout << endl;
	for (auto e : lt)
	{
		cout << e << ' ';
	}
	cout << endl;
	list<int>::reverse_iterator rit = lt.rbegin();
	while (rit != lt.rend())
	{
		cout << *rit << ' ';
		rit++;
	}
	cout << endl;
}
int main()
{
	Test();
	return 0;
}

 1.4  常见接口函数的使用

void Test1()
{
	list<int> lt;
	lt.push_front(1);
	lt.push_front(3);
	lt.push_front(5);
	lt.push_front(7);
	lt.push_front(9);
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	list<int>::iterator it = find(lt.begin(), lt.end(), 3);
	lt.insert(it, 2);
	lt.erase(it);

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
	lt.pop_back();
	lt.pop_front();
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
	cout << lt.size();
}

2、list的模拟实现

 2.1  基本框架

2.1.1 节点、list及其构造

list是个双向带头循环列表，要定义其节点以及其哨兵位头节点

list的节点类

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

节点类设计完后我们就可以开始实现list类

前面说了要用哨兵位头节点去带

namespace xxx
{
    // List的节点类
    template<class T>
    struct ListNode
    {
        ListNode<T>* _prev;
        ListNode<T>* _next;
        T _val;
        ListNode(const T& val = T())
            :_next(nullptr)
            , _prev(nullptr)
            , _val(val)
        {}
    };
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
    public:
        list()
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }
    private:
        Node* _head;
    };
};

哨兵位头节点是指向list的所以是指针，构造时最开始只有头节点所以new一个空间然后头节点的前后都指向自己

2.1.2 push_back

后面其实可以直接调用insert，在end()位置插入就相当于尾插了

void push_back(const T& x)
{
    Node* newnode = new Node(x);
    Node* tail = _head->_prev;
    tail->_next = newnode;
    newnode->_prev = tail;
    newnode->_next = _head;
    _head->_prev = newnode;
}

2.2 迭代器的实现

2.2.1 构造

list 的重点是迭代器，因为这里的迭代器的实现和我们之前讲的实现方式都不同。

我们之前讲的string和vector的迭代器都是一个原生指针，实现起来是非常简单的。

但是list是一个链表，你的迭代器还能这样去实现吗？在空间上不是连续的，如何往后走？

也就是++不能只指向后面的位置，应该重载++；且解引用*也没办法取到list中的数据val也要重载

    template<class T>
    struct __list_iterator
    {
        typedef ListNode<T> Node;
        Node* _node;
        __list_iterator(Node* x)
            :_node(x)
        {}
    };

迭代器可以理解为指向某个节点的指针，所以我这就用指针定义了

构造就只构造这一个就行了

2.2.2 重载

++、前置++、--、前置--

        typedef __list_iterator self;
        self& operator++()
        {
            _node = _node->_next;
            return *this;
        }
        self& operator++(int)
        {
            Self tmp(*this);
            _node = _node->_next;
            return tmp;
        }
        self& operator--()
        {
            _node = _node->_prev;
            return *this;
        }
        self& operator--(int)
        {
            Self tmp(*this);
            _node = _node->_prev;
            return tmp;
        }

解引用

        T& operator*()
        {
            return _node->_val;
        }
        T* operator->()
        {
            return &(operator*());
        }

==和!=

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

2.2.3 begin()和end()

    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef __list_iterator<T> iterator;
    public:
        list()
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }
        iterator begin()
        {
            //哨兵位头节点的下一节点才是头
            return _head->_next;
        }

        iterator end()
        {
            return _head;
        }

    private:
        Node* _head;
    };

2.2.4const迭代器

普通迭代器访问普通对象，可读可写；const 迭代器访问 const 对象，可读但不可写。

所以这里自然是需要实现 const 迭代器，即实现一个 "可读但不可写" 的迭代器。(可以 ++ 可以解引用，但解引用的时候不能修改)所以直接在 __list_iterator 里面重载一个 const 类型的 operator* 解决不了问题，我们得重新实现一个 __const_list_iterator 出来。

在迭代器类定义templa模板时添加两个参数 typedef记得改

 

与此同时list类的传参和typedef也得改

 这时候list_print就可以跑了

2.3 list的增删、深浅拷贝及析构

2.3.1增删

insert在pos前插入

        iterator insert(iterator pos, const T& x)
        {
            Node* cur = pos._node;
            Node* prev = cur->_prev;

            Node* newnode = new Node(x);

            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;

            return newnode;
        }

头插、尾插

        void push_front(const T& x)
        {
            insert(begin(), x);
        }
        void push_back(const T& x)
        {
            //Node* newnode = new Node(x);
            //Node* tail = _head->_prev;
            //tail->_next = newnode;
            //newnode->_prev = tail;
            //newnode->_next = _head;
            //_head->_prev = newnode;
            insert(end(), x);
        }

erase删pos位置的节点返回该节点的下一个位置

        iterator erase(iterator pos)
        {
            assert(pos != end());
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* next = cur->_next;
            prev->_next = next;
            next->_prev = prev;
            delete cur;
            return next;
        }

头删尾删

        void pop_back()
        {
            erase(--end());
        }
        void pop_front()
        {
            erase(begin());
        }

2.3.2 深浅拷贝

拷贝构造

        //拷贝构造
        list(list<T>& lt)
        {
            empty_init();
            for (const auto& e : lt)
            {
                push_back(e);
            }
        }

赋值重载

        void swap(list<T>& tmp)
        {
            std::swap(_head, tmp._head);
        }
        list<T>& operator=(list <T>&lt)
        {
            swap(lt);
            return *this;
        }

2.3.3 clear和析构

        void clear()
        {
            iterator it = begin();
            while (it!=end())
            {
                it = erase(it);
            }
        }
        ~list()
        {
            clear();
            delete _head;
            _head = nullptr;
        }

2.4 代码

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
namespace xxx
{
    // List的节点类
    template<class T>
    struct ListNode
    {
        ListNode<T>* _prev;
        ListNode<T>* _next;
        T _val;
        ListNode(const T& val = T())
            :_next(nullptr)
            , _prev(nullptr)
            , _val(val)
        {}
    };









    template<class T,class Ref,class Ptr>
    struct __list_iterator
    {
        typedef ListNode<T> Node;
        typedef __list_iterator<T,Ref,Ptr> self;
        Node* _node;
        __list_iterator(Node* x)
            :_node(x)
        {}
        self& operator++()
        {
            _node = _node->_next;
            return *this;
        }
        self& operator++(int)
        {
            self tmp(*this);
            _node = _node->_next;
            return tmp;
        }
        self& operator--()
        {
            _node = _node->_prev;
            return *this;
        }
        self& operator--(int)
        {
            self tmp(*this);
            _node = _node->_prev;
            return tmp;
        }
        Ref operator*()
        {
            return _node->_val;
        }
        Ptr operator->()
        {
            return &(operator*());
        }
        bool operator!=(const self& l)
        {
            return _node != l._node;
        }
        bool operator==(const self& l)
        {
            return _node == l._node;
        }
    };









    template<class T>
    class list
    {
        typedef ListNode<T> Node;

    public:
        typedef __list_iterator<T, T&, T*> iterator;
        typedef __list_iterator<T, const T&, const T*> const_iterator;
        list()
        {
            empty_init();
        }
        void empty_init()
        {
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }
        //拷贝构造
        list(list<T>& lt)
        {
            empty_init();
            for (const auto& e : lt)
            {
                push_back(e);
            }
        }
        void swap(list<T>& tmp)
        {
            std::swap(_head, tmp._head);
        }
        list<T>& operator=(list <T>&lt)
        {
            swap(lt);
            return *this;
        }

        void clear()
        {
            iterator it = begin();
            while (it!=end())
            {
                it = erase(it);
            }
        }
        ~list()
        {
            clear();
            delete _head;
            _head = nullptr;
        }
        iterator begin()
        {
            //哨兵位头节点的下一节点才是头
            return _head->_next;
        }
        const_iterator begin()const
        {
            return _head->_next;
        }
        iterator end()
        {
            return _head;
        }
        const_iterator end()const
        {
            return _head;
        }

        iterator insert(iterator pos, const T& x)
        {
            Node* cur = pos._node;
            Node* prev = cur->_prev;

            Node* newnode = new Node(x);

            prev->_next = newnode;
            newnode->_prev = prev;
            newnode->_next = cur;
            cur->_prev = newnode;

            return newnode;
        }
        void push_front(const T& x)
        {
            insert(begin(), x);
        }
        void push_back(const T& x)
        {
            //Node* newnode = new Node(x);
            //Node* tail = _head->_prev;
            //tail->_next = newnode;
            //newnode->_prev = tail;
            //newnode->_next = _head;
            //_head->_prev = newnode;
            insert(end(), x);
        }
        iterator erase(iterator pos)
        {
            assert(pos != end());
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* next = cur->_next;
            prev->_next = next;
            next->_prev = prev;
            delete cur;
            return next;
        }
        void pop_back()
        {
            erase(--end());
        }
        void pop_front()
        {
            erase(begin());
        }


    private:
        Node* _head;
    };

    void list_print(const list<int>& lt)
    {
        list<int>::const_iterator it = lt.begin();
        while (it != lt.end())
        {
            cout << *it << ' ';
            it++;
        }
        cout << endl;
    }


};

C++STL之list
qq_54866651的博客
06-01 239
的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。迭代到该位置，在这段位置上迭代需要线性的时间开销；最大的缺陷是不支持任意位置的随机访问，比如：要访问。在插入元素时，要给所有的迭代器重新赋值，因为插入。迭代器失效即迭代器所指向的节点的无效，即该节。
C++_list简单源码剖析：list模拟实现
Lvision2的博客
05-31 1312
->
STL 简介，标准模板库(zt)
11-06 1730
STL 简介，标准模板库［ZT］ 作者：Scott Field这篇文章是关于C++语言的一个新的扩展--标准模板库的（Standard Template Library），也叫STL。 当我第一次打算写一篇关于STL的文章的时候，我不得不承认我当时低估了这个话题的深度和广度。有很多内容要含盖，也有很多详细描述STL的书。因此我重新考虑了一下我原来的想法。我为什么要写这篇文章，又为什么要投稿呢？
手把手教你实现C++的list容器
最新发布
2401_86239408的博客
03-09 812
我们在这里用temp存取要插入位置的节点和用next存取它下一个节点，用cur动态分配一个空间存val，让temp后驱指针指向cur,cur的前驱指针指向temp,cur的后驱指针指向next,next的前驱节点指向cur,这样我们就完成了在任意位置的插入。这样，当我们使用 const 对象时，就会调用返回 const 迭代器的函数，确保在遍历过程中不会意外修改容器中的元素。而循环特性，则保证了链表的最后一个节点的后继指针指向头节点，头节点的前驱指针指向最后一个节点，形成一个完整的环。
stl-list
yiyele的博客
09-02 4271
STL之list容器详解List 容器list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。使用list容器之前必须加上头文件：#include;list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using names
C++ STL List
yearning_mjw的博客
11-27 360
个人学习记录
C++ STL list
XXXTENTAC1ON的博客
04-20 498
Listlist 的介绍list 的使用list 的创建访问、push_front、erase、unique、removelist 与 vector 的区别总结 list 的介绍 list是序列容器，允许在序列中的任何位置执行固定O(1)时间的插入和删除操作，并在两个方向上进行迭代 list容器使用双链表实现，双链表将每个元素存储在不同的存储位置，每个节点通过next，prev指针链接成顺序表 list与其他基本标准序列容器（array、vector和deque）相比，list通常在容器内的任何位置插入、
C++ 使用模板实现一个List的实例
08-30
List是链表的一种常见实现，通常用于存储和操作动态集合。在这个实例中，我们将使用模板类来创建一个通用的List，它能够容纳任何类型的数据，如`Stu`结构体。 首先，我们定义一个模板类`List<T>`，其中`T`代表存储...
list的讲解及模拟实现(c++)
weixin_49312527的博客
05-08 2540
与介绍vector时相同为了方便大家理解, 我们采用便模拟实现便讲解使用方式的方式, 展开对list容器的讲解. 一.list的介绍 使用时注意包含头文件: #include<list> list相关特性介绍: 1.list的底层是一个带头结点的双向循环链表. 2.list是可以在常数范围内在任意位置进行插入和删除的序列式容器, 并且该容器可以前后双向迭代. 3.list的底层是双向链表结构, 双向链表中每个元素存储在互不相关的独立节点中, 在节点中通过指针指向其前一个元素..
【C++】list类模拟实现
qq_66314292的博客
11-09 2375
list类的模拟实现
C++ STL之list的使用及模拟实现
czh1592272237的博客
01-23 2152
本篇文章详细讲解了STL中list的使用及模拟实现，以及反向迭代器类模板的实现。
C++STL之＜list＞
gangaue的博客
06-11 1475
本篇文章进行STL中list（双向链表）序列容器的学习！！！【list的文档介绍】list底层原理图(双向链表)： list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口举个栗子🌰： 【注意】举个栗子🌰： 举个栗子🌰： 举个栗子🌰： 注意：二个接口返回的是这个数据的引用，引用可以充当左值… 举个栗子🌰1️⃣： 举个栗子🌰2️⃣： 举个栗子🌰3️⃣： 迭代器失效：举个栗子🌰： 🍁2、list模拟实现 🍂..........
实现C++中的list
BUG制造机的博客
05-28 804
实现 C++ 中的 list
C++ STL list详解
dengguan2720的博客
07-24 305
一.解释： list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，list不仅是一个双向链表，而其还是一个环状双向链表。所以它只需要一个指针，便可以完整实现整个链表。list有一个重要性质：插入操作（insert）和合并操作（splice）都不会 造成原有的list迭代器失效。甚至 list...
C++——list
2301_79998744的博客
10-05 4486
list的模拟实现
C++学习_列表_二
测试
02-21 1120
list C++中的列表是一个双向链表,对插入删除的操作非常快 从最前面插入和从最后面插入 这两个可以实现栈和队列 #include <iostream> #include <list> using namespace std; int main() { list<int> a; a.push_front(10); a...
C++ 列表
qq_38315348的博客
02-25 984
C++ 高级列表 零蚀 链接描述 ???? 前言
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值