【C++】7-STL-list

最新推荐文章于 2024-08-15 23:25:21 发布
最新推荐文章于 2024-08-15 23:25:21 发布
阅读量80 收藏
点赞数
分类专栏： C++ 文章标签： c++ list stl 容器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68651804/article/details/132628359
版权

【C++】7-list

1. 了解list

list更详细的介绍

  1. list是序列容器，允许在序列内的任意位置进行常量时间的插入和删除，并进行前后两个方向的迭代。
  2. list的底层存储数据的内容是双向链表结构，双向链表中的每个元素存储在互不相关的独立结点中（即存储在不同且不相关的存储位置），且结点中通过指针指向其前一个元素和后一个元素。
  3. list和forward_list相似：主要区别在于forward_list的对象是单链表，只能向前迭代，以使其更简单且高效。
  4. 与其他基本标准序列容器(array、vector和deque)相比，list在容器内的任何位置插入、提取和移动元素(迭代器已经获得)方面通常表现更好，因此在大量使用插入、提取、移动等的算法(如排序算法)中也表现更好。
  5. 与其他序列容器相比，list和forward_lists的主要缺点是它们不支持元素的随机访问（即通过位置直接访问元素），例如，要访问列表中的第六个元素，必须从已知位置(如开始或结束)迭代到该位置，这需要在两者之间的距离上花费线性时间。它们还消耗一些额外的内存来保存与每个元素相关联的链接信息(对于存储类型较小元素的大型list来说，这可能是一个重要因素)。
  6. 带头结点

2. list的使用

与string、vector一样，list也有许多接口，但我们目前只需掌握其中比较常用且重要的接口即可。

（list的接口与vector类似，在vector那一文章中已经做了详细介绍，因此下面只是简要说明）

2.1 构造（constructor）

接口详细信息

函数功能说明
explicit list (const allocator_type& alloc = allocator_type());默认构造
explicit list (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());初始化为n个val
template list (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());利用迭代器的范围构造
list (const list& x);拷贝构造
operator=构造（赋值）
上述函数可等价于：
list(const value_type& val = value_type());
list(size_t n, const value_type& val = valye_type());
template list(InputIterator first, InputIterator last, const val = value_type());
list(const list& x);
operator=

2.2 迭代器（iterators）

list的迭代器不支持双目运算符+-（后面的modifiers会讲到）

函数功能说明
begin返回指向第一个元素的迭代器
end返回指向最后一个元素的下一个位置的迭代器
rbegin返回指向最后一个元素的下一个位置的迭代器
rend返回指向第一个元素的迭代器
cbegin 返回指向（const 对象的）第一个元素的迭代器。指向的内容不可修改
cend 返回指向（const 对象的）最后一个元素的下一个位置的迭代器。指向的内容不可修改

2.3 容量（capacity）

函数功能说明
empty判断list是否为空
sizelist大小（有效数据/结点个数）

2.4 元素访问（element acess）

函数功能说明
front取得第一个元素（头结点的下一个元素）
back取得最后一个元素（头结点的上一个元素）

2.5 修改（modifiers）

函数功能说明
assign重新分配list的内容
push_front头插
pop_front头删
push_back尾插
pop_back尾删
insert任意位置插入
erase任意位置删除
resize重新设置list大小
clear清空内容
swap交换两个结点的内容

测试用例：

void test_list1()
{
	list<int> It1;
	cout << "Initialize::>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	cout << "list<int> It1" << endl;
	Print(It1);
	// 1. assign
	cout << "assign:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	It1.assign(3, 10);
	cout << "It1.assign(3, 10)" << endl;
	Print(It1);
	// 2. push
	cout << "push_back和push_front:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	It1.push_back(1);
	It1.push_back(2);
	It1.push_front(3);
	It1.push_front(4);
	Print(It1);
	// 3. pop
	cout << "pop:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	It1.pop_back();
	It1.pop_front();
	Print(It1);
	// 4. insert
	// iterator insert (iterator position, const value_type& val);
	// void insert (iterator position, size_type n, const value_type& val);
	cout << "insert:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	list<int>::iterator it = ++It1.begin();// 迭代器无法使用双目运算符'+'/'-'
	// iterator insert (iterator position, const value_type& val);
	cout << "it = It1.insert(it, 100 + i)" << endl;
	for (size_t i = 0; i < 4; ++i)
	{
		// insert看实际情况选择是否重新接收it
		// it = It1.insert(it, 100 + i);
		It1.insert(it, 100 + i);
	}
	Print(It1);
	// template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last);
	list<int> It2;
	It2.push_back(10);
	It2.push_back(20);
	It2.push_back(30);
	It2.push_back(40);
	cout << "It1.insert(++It1.begin(), It2.begin(), It2.end())" << endl;
	It1.insert(++It1.begin(), It2.begin(), It2.end());
	Print(It1);	
	// 5. erase
	// iterator erase(iterator position);
	// iterator erase(iterator first, iterator last);// 这里不做介绍
	cout << "erase:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	it = find(It1.begin(), It1.end(), 100);// 使用算法库里的find()找到数据为100的结点
	for (size_t i = 0; i < 3; ++i)
	{
		it = It1.erase(it);// 删除成功后，返回原被删除的结点的下一个结点的迭代器
	}
	Print(It1);
	// 6. resize
	// void resize (size_type n, value_type val = value_type());
	cout << "resize:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	It1.resize(4);
	cout << "It1.resize(4)" << endl;
	Print(It1);
	It1.resize(5);
	cout << "It1.resize(5)" << endl;
	Print(It1);
	It1.resize(8, 1000);
	cout << "It1.resize(8, 1000)" << endl;
	Print(It1);
	// 7. swap
	cout << "swap:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	It1.swap(It2);
	cout << "It1.swap(It2)" << endl;
	cout << "It1:" << endl;
	Print(It1);
	cout << "It2:" << endl;
	Print(It2);
	// 8. clear
	cout << "clear:>>>>>>>>>>>>>>>>>>>>>>>" << endl;
	It1.clear();
	Print(It1);
}

输出结果：

image-20230716223955214

3. list进阶 – 模拟实现

以上内容可以帮你了解怎么使用list，但如果想要熟练使用，还需要了解list的底层实现。

// 反向迭代器类
// 这是一个容器适配器
// 关于反向迭代器的底层原理，可以看【C++】stack_queue文章
template<class Iterator, class Ref, class Ptr>
class ReverseIterator
{
	typedef ReverseIterator<Iterator, Ref, Ptr> Self;

public:
	ReverseIterator(Iterator it)
		:_iterator(it)
	{}

	Ref operator*()
	{
		Iterator tmp(_iterator);

		return *(--tmp);
	}
	Ptr operator->()
	{
		return &(operator*());
	}
	// 前置
	Self& operator++()
	{
		--_iterator;

		return *this;
	}
	Self operator++(int)
	{
		Self tmp(_iterator);
		--tmp;

		return tmp;
	}
	// 前置
	Self& operator--()
	{
		++_iterator;

		return *this;
	}
	Self operator--(int)
	{
		Self tmp(_iterator);
		++tmp;

		return tmp;
	}
	bool operator==(const Self& s) const
	{
		return _iterator == s._iterator;
	}
	bool operator!=(const Self& s) const
	{
		return _iterator != s._iterator;
	}
private:
	Iterator _iterator;
};

/
namespace wzw
{
    // List的结点类
    template<class T>
    struct ListNode
    {
        // 提供默认构造
        ListNode(const T& val = T())
            :_pPre(nullptr)
            ,_pNext(nullptr)
            ,_val(val)
        {}

        ListNode<T>* _pPre;
        ListNode<T>* _pNext;
        T _val;
    };

    // List的迭代器类
    template<class T, class Ref, class Ptr>// Ref相当于T&，Ptr相当于T*
    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)
        {}

        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) const
        {
            return !(*this == l);
        }
        bool operator==(const Self& l) const
        {
            return _pNode == l._pNode;
        }
    public:
        PNode _pNode;
    };

    //list类
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
    public:
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T*> const_iterator;
        
        typedef ReverseIterator<iterator, T&, T*> reverse_iterator;
        typedef ReverseIterator<const_iterator, const T&, const T*> const_reverse_iterator;
    public:
        // List的构造
        // explicit list (const allocator_type& alloc = allocator_type());
        list()
        {
            // 空链表有一个头结点
            CreateHead();
        }
        // explicit list (size_type n, const value_type& val = value_type(),
        // const allocator_type& alloc = allocator_type());
        list(int n, const T& value = T())
        {
            CreateHead();

            for (size_t i = 0; i < n; ++i)
            {
                push_back(value);
            }
        }
        // template <class InputIterator>
        // list(InputIterator first, InputIterator last,const allocator_type& alloc = allocator_type());
        template <class InputIterator>
        list(InputIterator first, InputIterator last)
        {
            CreateHead();

            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        // list (const list& x);
        // list(const list& l)也是正确的
        list(const list<T>& l)
        {
            CreateHead();

            list<T> tmp(l.begin(), l.end());

            swap(tmp);
        }
        // list& operator= (const list& x);
        // 此写法是优化过的写法 -- 只是写着更简洁了，不考虑效率
        list<T>& operator=(list<T> l)
        {
            clear();

            swap(l);

            return *this;
        }
        ~list()
        {
            clear();

            delete _pHead;
            _pHead = nullptr;
        }

        // List Iterator
        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);
        }
        
        // 一般来说，rbegin()应该返回指向最后一个元素的迭代器end()-1，而非end()，这里之所以返回的是end()，而非end()-1，只是为了美观（正向和反向保持对称美）
        reverse_iterator rbegin()
        {
            return reverse_iterator(end());
        }
        reverse_iterator rend()
        {
            return reverse_iterator(begin());
        }
        const_reverse_iterator rbegin() const
        {
            return reverse_iterator(end());
        }
        const_reverse_iterator rend() const
        {
            return reverse_iterator(begin());
        }

        // List Capacity
        size_t size() const // 频繁调用，代价较大
        {
            size_t size = 0;

            const_iterator it = begin();
            while (it != end())
            {
                ++size;
                ++it;
            }

            return size;
        }
        bool empty() const
        {
            return begin() == end();
        }

        // List Access
        T& front()
        {
            return _pHead->_pNext->_val;
        }
        const T& front() const
        {
            return _pHead->_pNext->_val;
        }
        T& back()
        {
            return _pHead->_pPre->_val;
        }
        const T& back() const
        {
            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());
        }
        // iterator insert (iterator position, const value_type& val);
        // 在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            PNode newNode = new Node(val);
            PNode cur = pos._pNode;
            PNode pre = cur->_pPre;

            newNode->_pNext = cur;
            newNode->_pPre = pre;
            pre->_pNext = newNode;
            cur->_pPre = newNode;

            return iterator(newNode);
        }
        // iterator erase (iterator position);
        // 删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            assert(!empty());

            PNode cur = pos._pNode;
            PNode pre = cur->_pPre;
            PNode next = cur->_pNext;

            pre->_pNext = next;
            next->_pPre = pre;

            delete cur;
            cur = nullptr;

            return iterator(next);
        }
        void clear()
        {
            while (begin() != end())
            {
                pop_back();
            }
        }
        // void swap (list& x);
        void swap(list<T>& l)
        {
            std::swap(_pHead, l._pHead);
        }
    private:
        void CreateHead()
        {
            _pHead = new Node();
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }
        PNode _pHead;
    };
}

4. vector和list的比较

vector

优点：

  1. 支持元素下标的随机访问

  2. 尾插尾删效率较高

  3. cpu高速缓存命中率高

    即当获得数组首元素的地址时，将首元素存入高速缓冲区，同时将首元素紧接着后面的一些元素也存入高速缓冲区。之后若要访问这些被存入高速缓冲区的元素时，便可直接从缓冲区访问，而不必从内存访问，速度更快。

缺点：

  1. 前面部分的插入删除数据效率低，需要挪动数据，时间复杂度O(N)
  2. 扩容耗费时间（大可能是异地扩容），还可能存在空间浪费

list

优点：

  1. 空间按需申请/释放，无需扩容
  2. 任意位置插入数据效率高，时间复杂度O(1)

缺点：

  1. 不支持元素的下标随机访问
  2. cpu高速缓存命中率低（底层数据存储物理空间非连续）
丨归凡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
6.C++ STL之list
CarmenIsOK的博客
04-04 169
源代码 G2.9 sizeof(list)=4 link_node * 一个指针在32位系统是4字节 G4.9 sizeof(list)=8 template<class T,class Alloc=alloc> class list{ protected: typedef _list_node<T> list_node; public: typedef li...
【C++ STL】3.list
深思深练 厚积薄发
04-26 160
一、list基本概念 list是STL中链表数据结构的类型，在物理结构上非连续，通过指针进行链接。STL中的链表是双向循环链表，末尾节点后向指针指向初始节点，初始节点前向指向末尾节点。list迭代器只支持双向迭代器，即只能++或者– 与vector相比： 优点：充分利用内存，插入删除方便，不需要移动大量元素。 缺点：占用空间比较大，遍历时时间消耗比较多。 二、list构造 1）list<T> lst;默认无参 list<int>L; 2） list(beg,end);将[beg,
C++:STL--List
小青菜的博客
05-28 1272
C++list的学习
【C++】-- STL之list详解
局部变量和全局变量
06-06 1656
list有如下特征：（1）优点：可在任意位置插入删除元素，插入删除元素效率高（2）底层是双向链表，因此list可以前后双向迭代，通过指针连接前后节点。forward_list是单链表，只能向前迭代（3）缺点：不支持任意位置随机访问；需要额外空间保存前后节点信息......
C++ STL--list容器
积木的笔记
12-08 1734
C++ STL--list容器介绍
C++ - SGI 版本 STL源码
10-25
**C++ SGI版STL源码详解** STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法。SGI（Silicon Graphics, Inc.）公司在90年代为C++社区贡献了一...
SGI-STL_STL_C++_
10-04
SGI-STL是斯坦福大学图形系统集团（Silicon Graphics, Inc.）开发的一个C++标准模板库（Standard Template Library, STL）的实现版本，它对C++的STL进行了扩展和完善，为开发者提供了强大的容器、迭代器、算法和函数...
C++ stl-list.h(SGI)
10-12
有关list的源代码文件（SGI版本）
SGI-STL.zip
08-24
SGI-STL（Silicon Graphics, Inc....总之，SGI-STL.zip是一个宝贵的资源，对于深入理解和掌握C++ STL的内在机制非常有帮助。无论是初学者还是经验丰富的C++程序员，都能从中受益匪浅，提升自己的编程技能。
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中的一部分，它提供了丰富的容器、迭代器、算法和函数对象等组件，极大地简化了数据结构和算法的实现。余文溪的《C++ STL--数据结构与算法...
C语言 | Leetcode C语言题解之第337题打家劫舍III
m0_59237910的博客
08-15 125
C语言 | Leetcode C语言题解之第337题打家劫舍III
C++笔记5•内存管理•
qq_64446190的博客
08-12 1064
内存管理
C++练习之定义一个图书类
2402_83809362的博客
08-12 99
定义一个图书类，包含图书名字、价格、数量，将名字修改为指针(char *)类型，使用初始化列表完成图书信息初始化。
C++ | Leetcode C++题解之第337题打家劫舍III
Ddddddd_158的博客
08-15 166
C++ | Leetcode C++题解之第337题打家劫舍III
ubuntu22.04 安装 ros1
qq_35547879的博客
08-14 166
原先只知道ros1 noetic 只支持到ubuntu20.04。现在系统必须升级到ubuntu22.04。
【C语言】字符串操作函数详解
EleganceJiaBao的博客
08-14 685
这些头文件提供了字符串操作所需的函数声明。以下是常用字符串操作函数的详细讲解，包括每个函数的参数、返回值说明以及示例代码。每个函数的使用说明还包括了适当的表格以帮助理解其功能和用法。
C++笔记4•类和对象3•
qq_64446190的博客
08-12 654
类和对象3
1 基本概念
m0_62280492的博客
08-13 453
C语言基本概念
每天一道C语言精选编程题之自幂数
最新发布
huc_error的博客
08-15 146
我们可以使⽤⼀个循环遍历 1~100000 并检查每个数是否为⾃幂数。写⼀个代码打印1~100000之间的所有的⾃幂数，中间⽤空格分隔。3. 判断 sum 与 i 是否相等，相等则 i 是⾃幂数。2. 计算 i 的每⼀位的 n 次⽅之和 sum；注：可以使⽤ pow 函数求得某个数的次⽅数。幂数，因为 1^3+5^3+3^3=153。1. 计算 i 的位数 n；⾃幂数是指⼀个数的位数的n次。
C++ -- STL文件解析
08-27
STL是指标准模板库（Standard Template Library），它是C++语言的一部分，提供了一系列的模板类和函数，用于支持通用的数据结构和算法。STL的目标是提供高效、可重用和可扩展的组件，以便开发人员能够更轻松地编写高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

丨归凡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值