【C++】[STL]容器----List(讲解+模拟实现)

最新推荐文章于 2023-10-06 18:29:22 发布
最新推荐文章于 2023-10-06 18:29:22 发布
阅读量1k 收藏
点赞数
文章标签： c++ 链表 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63601181/article/details/127946963
版权
list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
下面正式进入List的学习。

一、list结构剖析

list 是一个双向循环链表

结点类：

template<class T>
	struct list_node // 节点
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;


		list_node(const T& x = T())
			: _data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

迭代器类：

template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> iterator;

		Node* _node;

        //.....
    }；

list 类：

template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;

        //......
        
    private:
		Node* _head;
	};

list类中包含上面两个类。

二、List 的使用

下面介绍list常用接口的使用。

2.1 list的构造

void list_test1()
{
    list<int> l1;                         // 构造空的l1
    list<int> l2(4, 100);                 // l2中放4个值为100的元素
    list<int> l3(l2.begin(), l2.end());  // 用l2的[begin(), end()）左闭右开的区间构造l3
    list<int> l4(l3);                    // 用l3拷贝构造l4

    // 以数组为迭代器区间构造l5
    int array[] = { 16,2,77,29 };
    list<int> l5(array, array + sizeof(array) / sizeof(int));

    // 列表格式初始化C++11
    list<int> l6{ 1,2,3,4,5 };

    // 用迭代器方式打印l5中的元素
    list<int>::iterator it = l5.begin();
    while (it != l5.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    // C++11范围for的方式遍历
    for (auto& e : l5)
        cout << e << " ";

    cout << endl;
}

 

2.2 list iterator 的使用 

1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动   
void list_test2()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    list<int> l(array, array + sizeof(array) / sizeof(array[0]));
    // 使用正向迭代器正向list中的元素
    // list<int>::iterator it = l.begin();   // C++98中语法
    auto it = l.begin();                     // C++11之后推荐写法
    while (it != l.end())
    {
        cout << *it << " ";
        ++it;
    }
    cout << endl;

    // 使用反向迭代器逆向打印list中的元素
    // list<int>::reverse_iterator rit = l.rbegin();
    auto rit = l.rbegin();
    while (rit != l.rend())
    {
        cout << *rit << " ";
        ++rit;
    }
    cout << endl;
}

 

2.3 list capacity

 

2.4 list element access

 

2.5 list modififiers  

void PrintList(const list<int>& l)
{
    // 注意这里调用的是list的 begin() const，返回list的const_iterator对象
    for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it)
    {
        cout << *it << " ";
        // *it = 10; 编译不通过
    }

    cout << endl;
}

// list插入和删除
// push_back/pop_back/push_front/pop_front
void list_test3()
{
    int array[] = { 1, 2, 3 };
    list<int> L(array, array + sizeof(array) / sizeof(array[0]));

    // 在list的尾部插入4，头部插入0
    L.push_back(4);
    L.push_front(0);
    PrintList(L);

    // 删除list尾部节点和头部节点
    L.pop_back();
    L.pop_front();
    PrintList(L);
}

 

2.6 list的迭代器失效  

迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。 
void TestListIterator1()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    list<int> l(array, array + sizeof(array) / sizeof(array[0]));
    auto it = l.begin();
    while (it != l.end())
    {
        // erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋值
        l.erase(it);
        ++it;
    }
}

 

改正：

void TestListIterator()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    list<int> l(array, array + sizeof(array) / sizeof(array[0]));
    auto it = l.begin();
    while (it != l.end())
    {
        l.erase(it++); // it = l.erase(it);
    }
}

三、模拟实现list

list.h

#pragma once
#include <iostream>
#include <assert.h>
#include <algorithm>
#include <time.h>

using namespace std;

namespace Abert
{
	template<class T>
	struct list_node // 节点
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;


		list_node(const T& x = T())
			: _data(x)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};


	// 迭代器 像指针一样的对象
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref, Ptr> iterator;

		Node* _node;


		__list_iterator(Node* node)
			:_node(node)
		{}


		bool operator!=(const iterator& it) const
		{
			return _node != it.node;
		}



		bool operator==(const iterator& it) const
		{
			return _node == it.node;
		}




		Ref operator*()
		{
			return _node->_data;
		}




		Ptr operator->()
		{
			return &(operator*());
		}



		// ++it
		iterator operator++()
		{
			_node = _node->_next;
			return *this;
		}



		// it++
		iterator operator++(int)
		{
			iterator tmp(*this);
			_node = _node->_next;
			return tmp;
		}



		// --it
		iterator operator--()
		{
			_node = _node->_prev;
			return *this;
		}



		
		// it--
		iterator operator--(int)
		{
			iterator tmp(*this);
			_node = _node->_prev;
			return tmp;
		}

	};




	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		typedef __list_iterator<T, T&, T*> iterator;
		typedef __list_iterator<T, const T&, const T*> const_iterator;



		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}


		const_iterator end() const
		{
			return const_iterator(_head);
		}



		iterator begin()
		{
			return const_iterator(_head->_next);
		}



		iterator end()
		{
			return const_iterator(_head);
		}




		void empty_init()
		{
			// 创建并初始化头节点
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}




		template <class InputIterator>
		list(InputIterator first, InputIterator last)
		{
			empty_init();

			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}






		list()
		{
			_head = new Node;
			_head->next = _head;
			_head->prev = _head;
		}





		void swap(list<T>& x)
		{
			std::swap(_head, x._head);
		}




		list(const list<T>& it)
		{
			empty_init();

			list<T> tmp(it.begin, it.end);
			swap(tmp);
		}




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





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




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








		void push_back(const T& x)
		{
			/*Node* tail = head->_prev;
			Node* newnode = new Node(x);

			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			head->_prev = newnode;*/

			insert(end(), x);
		}



		void push_front(const T& x)
		{
			insert(begin(), x);
		}



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

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

			return iterator(newnode);
		}



		void pop_back()
		{
			erase(end());
		}



		void pop_front()
		{
			erase(begin());
		}




		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 iterator(next);
		}

	private:
		Node* _head;
	};


}

list 的反向迭代器

ReverseListIterator.h

#pragma once
#include "list.h"

template<class Iterator>
class ReverseListIterator
{
	// 注意：此处typename的作用是明确告诉编译器，Ref是Iterator类中的类型，而不是静态成员变量
	// 否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量
	// 因为静态成员变量也是按照 类名::静态成员变量名 的方式访问的
public:
	typedef typename Iterator::Ref Ref;
	typedef typename Iterator::Ptr Ptr;
	typedef ReverseListIterator<Iterator> Self;
public:
	//
	// 构造
	ReverseListIterator(Iterator it) : _it(it) {}
	//
	// 具有指针类似行为
	Ref operator*() {
		Iterator temp(_it);
		--temp;
		return *temp;
	}
	Ptr operator->() { return &(operator*()); }
	//
	// 迭代器支持移动
	Self& operator++() {
		--_it;
		return *this;
	}
	Self operator++(int) {
		Self temp(*this);
		--_it;
		return temp;
	}
	Self& operator--() {
		++_it;
		return *this;
	}
	Self operator--(int)
	{
		Self temp(*this);
		++_it;
		return temp;
	}
	//
	// 迭代器支持比较
	bool operator!=(const Self& l)const { return _it != l._it; }
	bool operator==(const Self& l)const { return _it != l._it; }
	Iterator _it;
};

四、vector 与 list 的比较

vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

 

以上就是本文的全部内容，欢迎大家学习交流。

Abert—
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
std::List使用总结
大山喵写博客的地方
10-13 2万+
List 　　List使用一个doubly linked list(双向串列)管理元素，按惯例，C++标准库并未明定实现方式，只是遵守list的名称、限制和规格。 　　使用list时必须先包含头文件 #include&amp;amp;amp;lt;list&amp;amp;amp;gt; 　　其中的list类型定义于namespace std 中，是一个class template： template&amp;amp;amp;lt; class T,
STL-list的使用 详细说明
来信
12-09 1462
listlist是一个具有头结点的双向循环链表，结构较为复杂，但是非常高效。 现在我创建一个list对象 首先需要包头文件：#include <list>std::list<int> l1;这个例子中，我实例化出了一个存int类型的对象。接下来我参考cpulscpuls.com，介绍接口的用法：一：数据操作：1.assign：①： void assign (size_type n, const
C++ STL标准库： std::list使用介绍、用法详解
超级大洋葱的博客
12-16 8万+
文章目录0. std::list 简介1 std::list 定义对象2 std::list添加元素3 std::list删除元素4 std::list容器容量5 std::list迭代器6 std::list判断是否为空7 std::list元素的存取和访问8 std::list元素重置9 std::list 交换两个容器的内容10 std::list元素的插入和删除11 std::list运算符函数12 std::list merge()和sort()13 std::list remove() 和 re
【学习】C++(3) std list
小菲的进程
07-04 1463
定义：std：：list var_name;  //inclued 使用举例： std：：list filedname； 获取第一个值：filedname.front;  删除第一个值：filedname.pop_front; 获取最后一个值：filedname.back;  删除第一个值：filedname.pop_back;   1）初始化： (1) MyVector
[转] C++ STL标准库： std::list使用介绍、用法详解
sroman的博客
03-01 3502
https://blog.csdn.net/u014779536/article/details/111301635
C++ - SGI 版本 STL源码
10-25
C++ SGI版本的STL(标准模板库) 源码 在网上找了很久没有找到直接打包的STL源码, 就打包了一下发出来了 SGI版本的，比较容易阅读 可读性还可以有需要的可以拿走
stl-thumb:STL文件的缩略图生成器
05-13
Stl-thumb是用于STL文件的快速轻量级缩略图生成器。 它可以在Linux和Windows的文件管理器中显示STL文件的预览。 它是用Rust编写的，并使用OpenGL。 安装 视窗 Stl-thumb需要64位Windows 7或更高版本。 最新版本并...
C++ stl-list.h(SGI)
最新发布
10-12
有关list的源代码文件（SGI版本）
[C++]STL-vector容器
01-06
vector容器（动态数组，可变数组） 单口容器 vector动态增长的基本原理 当插入新元素时，如果空间不足，那么vector会重新申请更大的一块内存空间，将原来空间拷贝到新空间上，释放旧空间的数据，再把新元素插入新...
c语言读取stl文件,C++ list（STL list）访问（获取）元素方法详解
weixin_39957951的博客
05-23 1232
list 的成员函数 front() 和 back()，可以各自返回第一个和最后一个元素的引用。在空 list 中调用它们中的任意一个，结果是未知的，因此不要这样使用。可以通过迭代器的自增或自减来访问 list 的内部元素。正如我们所了解的那样，begin() 和 end() 分别返回的是指向第一个和最后一个元素下一个位置的双向迭代器。rbegin() 和 rend() 函数返回的双向迭代器，可以...
list 用法
jkchen's Haven
02-05 864
学了很多东西后才记起来有个叫list的东西，今天来补一补缺 声明一个int型的list：list a； 1、list的构造函数 lista{1,2,3} lista(n) //声明一个n个元素的列表，每个元素都是0 lista(n, m) //声明一个n个元素的列表，每个元素都是m lista(first, last) //声明一个列表，其元素的初始值来源于由区间所指定的序列...
STL之序列式容器(五)、list容器
学无止尽，谨言慎行！
04-10 722
一、list(STL list)使用、创建和初始化 list<T> 容器模板定义在 list 头文件中，是 T 类型对象的双向链表。 list 容器具有一些 vector 和 deque 容器所不具备的优势，它可以在常规时间内，在序列已知的任何位置插入或删除元素。这是我们使用 list，而不使用 vector 或 deque 容器的主要原因。 list 的缺点是无法通过位置来直接访问序...
list用法
ShineEternal的笔记小屋
05-25 332
本文为转载文章 1.关于list容器 list是一种序列式容器。list容器完成的功能实际上和数据结构中的双向链表是极其相似的，list中的数据元素是通过链表指针串连成逻辑意义上的线性表，也就是list也具有链表的主要优点，即：在链表的任一位置进行元素的插入、删除操作都是快速的。list的实现大概是这样的：list的每个节点有三个域：前驱元素指针域、数据域和后继元素指针域。前驱元素指针域...
C++ 学习系列 -- std::list
qq_33775774的博客
10-06 1535
list 是 c++ 中的序列式容器，其实现是双向链表，每个元素都有两个指针，分别指向前一个节点与后一个节点链表与数组都是计算机常用的内存数据结构，与数组连续内存空间不一样的地方在于，链表的空间是不连续的，链表是将一块块不连续的内存串联起来使用。正是由于链表的内存不连续这一特点，所以不能像数组一样，可以根据位置随机的访问每个元素，而链表我们压根不知道每个元素的实际位置到底在哪块内存区域。查找某个元素需要遍历整个链表，直到找到目标元素位置，时间复杂度是 O(n)；
C++ list 类学习笔记
热门推荐
whz_zb的专栏
09-29 10万+
双向循环链表list         list是双向循环链表，，每一个元素都知道前面一个元素和后面一个元素。在STL中，list和vector一样，是两个常被使用的容器。和vector不一样的是，list不支持对元素的任意存取。list中提供的成员函数与vector类似，不
C++STLlist容器数据存取
码云仓库地址：https://gitee.com/lance-gyq
03-09 247
C++STLlist容器数据存取 功能描述： 对list容器中数据进行存取 函数原型： front(); //返回第一个元素 back(); //返回最后一个元素 代码示例： #include<iostream> #include<list> using namespace std; void test01() { list<int>L1; L1.push_back(10); L1.push_back(20);
STL STD::list使用说明
lanyzh0909的专栏
05-15 5万+
stl list使用说明 使用标准的std::list进行容器数据处理时，操作比较底层。我们可以，减少引用标准MFC标准库，减少系统的大小，但同时也存在有不方便的操作之处，这里同大家分享一些使用心得......       在使用std::list::iterator链表遍历器进行访问 list     STL 中的list 就是一 双向链表，可高效
C++中list的使用方法及常用list操作总结
m0_37635769的博客
06-08 2508
C++中list的使用方法及常用list操作总结
C++ 面向对象 - STL 的应用
04-27
STL（Standard Template Library，标准模板库）是 C++ 的一个重要组成部分，它提供了一系列的容器、算法和迭代器等工具，使得 C++ 编程变得更加高效和方便。STL 中的容器包括 vector、list、set、map 等等，算法包括排序、查找、合并等等，迭代器则是一种通用的遍历容器元素的方式。 在面向对象编程中，STL 的应用非常广泛。例如，可以使用 vector 容器来表示一个动态数组，使用 map 容器来表示一个关联数组，使用 set 容器来表示一个集合等等。此外，STL 的算法可以方便地应用于各种容器中，例如对一个 vector 进行排序、查找等操作。 除此之外，STL 还提供了一些函数对象（Functors）和适配器（Adapters），这些工具可以方便地实现一些高级功能，例如函数指针的封装、容器元素的自定义排序等等。总之，STL 是 C++ 中非常重要的一个库，它可以帮助我们更加方便和高效地进行面向对象编程。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值