C++ STL——模拟实现List

最新推荐文章于 2023-04-03 21:50:37 发布
最新推荐文章于 2023-04-03 21:50:37 发布
阅读量437 收藏 6
点赞数 5
分类专栏： C++ 文章标签： c++ 链表 STL 模拟实现list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50886514/article/details/116420956
版权

文章目录：

1. List的介绍

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

2. STL-List的使用

2.1 list的构造

在这里插入图片描述
可以通过如下两种方式对链表进行访问

方法一：

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

void main()
{
	list<int> mylist;
	for (const auto &e : mylist)
	{
		cout << e << " ";
	}
	cout << endl;
}

方法二

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

void main()
{
	list<int> mylist;
	list<int>::iterator it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
}

如上几个函数的使用：
（1）构造n个val值(若未给默认是0)

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

void main()
{
	list<int> mylist(10,5);
	list<int>::iterator it = mylist.begin();
	cout << "head-->";
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end"<<endl;
}

在这里插入图片描述
（2）拷贝构造函数(用一个链表拷贝构造另一个链表)

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

void main()
{
	list<int> mylist(10, 5);
	//拷贝构造
	list<int> youlist = mylist;
	list<int>::iterator it = youlist.begin();
	cout << "head-->";
	while (it != youlist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;
}

在这里插入图片描述
（3）用一个区间的数据构造(包含区间左边，不包含区间右边，[ ))

  • 通过指针区间构造
#include<iostream>
#include<list>
using namespace std;

void main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int n = sizeof(arr) / sizeof(arr[0]);
	//是一个左闭右开的区间[ )
	list<int> mylist(arr,arr+n);
	list<int>::iterator it = mylist.begin();
	cout << "head-->";
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end"<<endl;
}

在这里插入图片描述

  • 通过迭代器区间构造
#include<iostream>
#include<list>
using namespace std;

void main()
{
	list<int> mylist(10,5);
	//通过迭代器区间构造
	list<int> youlist(mylist.begin(),mylist.end());
	list<int>::iterator it = youlist.begin();
	cout << "head-->";
	while (it != youlist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;
}

在这里插入图片描述

2.2 List迭代器的使用

在这里插入图片描述

  • begin()与end()为正向迭代器，对迭代器执行++操作，迭代器向后移动
  • rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

对比使用如下：

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

void main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int n = sizeof(arr) / sizeof(arr[0]);
	list<int> mylist(arr,arr+n);
	//正向迭代器
	list<int>::iterator it = mylist.begin();
	cout << "head-->";
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end"<<endl;
	//反向迭代器
	list<int>::reverse_iterator rit = mylist.rbegin();
	cout << "head-->";
	while (rit != mylist.rend())
	{
		cout << *rit << "-->";
		++rit;
	}
	cout << "end" << endl;
}

在这里插入图片描述

2.3 list capacity

在这里插入图片描述

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

void main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int n = sizeof(arr) / sizeof(arr[0]);
	list<int> mylist(arr, arr + n);
	//判空
	cout << "empty = " << mylist.empty() << endl;
	//求链表元素个数
	cout << "size = " << mylist.size() << endl;
}

在这里插入图片描述

2.4 获取头尾元素(因为返回的是引用，所以可赋值修改)

在这里插入图片描述

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

void main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int n = sizeof(arr) / sizeof(arr[0]);
	list<int> mylist(arr, arr + n);
	//访问头尾节点
	cout << "oldfront = " << mylist.front() << endl;
	cout << "oldback = " << mylist.back() << endl;
	//修改头尾节点
	mylist.front() = 999;
	mylist.back() = 444;
	cout << "newfront = " << mylist.front() << endl;
	cout << "newback = " << mylist.back() << endl;
	list<int>::iterator it = mylist.begin();
	cout << "head-->";
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;
}

在这里插入图片描述

2.5 List的修改方法

在这里插入图片描述
链表的插入删除

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

void main()
{
	list<int> mylist;
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int n = sizeof(arr) / sizeof(arr[0]);
	//尾插
	mylist.push_back(1);
	mylist.push_back(2);
	mylist.push_back(3);
	mylist.push_back(4);
	mylist.push_back(5);
	//头插
	mylist.push_front(0);
	//在pos位置插入val
	list<int>::iterator pos = find(mylist.begin(), mylist.end(), 3);
	mylist.insert(pos, 99);

	//删除pos位置的值
	/*mylist.erase(pos);*/

	//插入n个值
	/*mylist.insert(pos, 5, 333);*/

	//插入一个区间
	/*mylist.insert(pos, arr, arr + 3);*/

	list<int>::iterator it = mylist.begin();
	while(it != mylist.end())
	{
		cout << *it <<"-->";
		++it;
	}
	cout << "end" << endl;
}

链表的交换

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

void main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	list<int> mylist(arr,arr+5);
	list<int> youlist(arr + 5, arr + 10);
	cout << "交换前:" << endl;
	list<int>::iterator it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;
	list<int>::iterator yit = youlist.begin();
	while (yit != youlist.end())
	{
		cout << *yit << "-->";
		++yit;
	}
	cout << "end" << endl;

	//交换两个链表
	mylist.swap(youlist);
	cout << "交换后:" << endl;

	it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;
	yit = youlist.begin();
	while (yit != youlist.end())
	{
		cout << *yit << "-->";
		++yit;
	}
	cout << "end" << endl;
}

在这里插入图片描述

2.6 排序sort()

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

void main()
{
	int arr[] = { 1, 9, 4, 2, 5,  10,  6, 7,3, 8};
	int n = sizeof(arr) / sizeof(arr[0]);
	list<int> mylist(arr, arr + n);
	list<int>::iterator it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;

	//从小到大排序
	mylist.sort();
	it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;

	//从大到小排序
	mylist.sort(greater<int>());
	it = mylist.begin();
	while (it != mylist.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "end" << endl;
}

在这里插入图片描述

3.List的迭代器失效

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

举例如下：
在这里插入图片描述
如上图所示，删除迭代器it所指向的节点，此时迭代器已经失效，不能再对迭代器操作，虽然迭代器 it 失效，但是不会影响其他迭代器，如下图所示 it1 可以正常访问
在这里插入图片描述
删除节点的返回值是删除节点的下一个节点的迭代器

例题：如下代码可以正常运行吗？

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

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())
	{
		l.erase(it);
		++it;
	}
}
void main()
{
	TestListIterator1();
}

如上代码肯定是不能运行的，因为erase()函数执行之后，it所指向的节点已被删除，删除之后迭代器已经失效，不能在对迭代器操作，应接收erase()的返回值，修改如下：

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

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())
	{
		//it不需要++，删除节点的返回值是删除节点的下一个节点的迭代器
		it = l.erase(it);
	}
}
void main()
{
	TestListIterator1();
}

4. List的模拟实现

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


namespace MyList
{
	template<class _Ty>
	class List;
	template<class _Ty>
	class ListIterator;


	//节点类
	template<class _Ty>
	class ListNode
	{
		friend class List<_Ty>;
		friend class ListIterator<_Ty>;
	public:
		//节点的构造函数
		ListNode() :_Value(_Ty()), _Next(nullptr), _Prev(nullptr)
		{}
		ListNode(_Ty Val, ListNode* next = nullptr, ListNode* prev = nullptr) :_Value(Val), _Next(next), _Prev(prev)
		{}
		//节点的析构函数
		~ListNode()
		{}
	private:
		_Ty       _Value;
		ListNode* _Next;
		ListNode* _Prev;
	};




	//迭代器类
	template<class _Ty>
	class ListIterator
	{
		typedef ListIterator _It;
	public:
		//迭代器的构造
		ListIterator() :_Ptr(nullptr)
		{}
		ListIterator(ListNode<_Ty>* _P) :_Ptr(_P)
		{}
	public:
		bool operator!=(const _It &it)
		{
			return _Ptr != it._Ptr;
		}
		bool operator==(const _It &it)
		{
			return _Ptr == it._Ptr;
		}
		_Ty& operator*()
		{
			return (_Ptr->_Value);
		}
		_It& operator++()
		{
			_Ptr = _Ptr->_Next;
			return *this;
		}
	public:
		ListNode<_Ty>* _MyNode()
		{
			return _Ptr;
		}
	public:
		_It& operator--()
		{
			_Ptr = _Ptr->_Prev;
			return *this;
		}
	private:
		ListNode<_Ty>* _Ptr;
	};




	//链表类
	template<class _Ty>
	class List
	{
	public:
		typedef ListNode<_Ty>* _Nodeptr;
		typedef ListIterator<_Ty> iterator;
	public:
		//求节点个数
		size_t size()const
		{
			return _Size;
		}
		//判空
		bool empty()const
		{
			return (size() == 0);
		}

	public:
		//迭代器
		iterator begin()
		{
			return iterator(_Head->_Next);
		}
		iterator end()
		{
			return iterator(_Head);
		}
	public:
		//插入
		iterator insert(iterator pos, const _Ty &x)
		{
			_Nodeptr cur = pos._MyNode();
			_Nodeptr _S = new ListNode<_Ty>(x);
			_S->_Next = cur;
			_S->_Prev = cur->_Prev;
			_S->_Next->_Prev = _S;
			_S->_Prev->_Next = _S;
			++_Size;
			return iterator(_S);
		}
		//在pos位置插入n个x,
		void insert(iterator pos, size_t n, const _Ty &x)
		{
			while (n--)
			{
				insert(pos, x);
			}
		}
	public:
		//尾插
		iterator push_back(const _Ty &x)
		{
			return insert(end(), x);
		}
		//头插
		iterator push_front(const _Ty &x)
		{
			return insert(begin(), x);
		}
	public:
		//删除pos位置的节点，返回该节点的下一个位置
		iterator erase(iterator pos)
		{
			_Nodeptr cur = pos._MyNode();
			_Nodeptr next_node = cur->_Next;
			cur->_Prev->_Next = cur->_Next;
			cur->_Next->_Prev = cur->_Prev;

			delete cur;

			_Size--;

			return iterator(next_node);
		}
	public:
		//删除一个区间
		iterator erase(iterator first, iterator last)
		{
			while (first != last)
			{
				first = erase(first);
			}
			return first;
		}
		//清除
		void clear()
		{
			erase(begin(), end());
		}
	public:
		//尾删
		iterator pop_back()
		{
			return erase(--end());
		}
		//头删
		iterator pop_front()
		{
			return erase(begin());
		}
	public:
		//求头节点
		_Ty & Front()
		{
			return *begin();
		}
		const _Ty & Front()const
		{
			return *begin();
		}
		//求尾节点
		_Ty & Back()
		{
			return *--end();
		}
		const _Ty & Back()const
		{
			return *--end();
		}
	public:
		//交换函数
		void swap(List<_Ty> & lt)
		{
			//用系统里的交换函数
			std::swap(_Head, lt._Head);
			std::swap(_Size, lt._Size);
		}
	public:
		//List的构造函数
		List() :_Head(BuyNode()), _Size(0)
		{}
		List(size_t n, const _Ty & x = _Ty()) :_Size(0)
		{
			_Head = BuyNode();
			insert(end(), n, x);
		}
		List(const _Ty *first, const _Ty *last) :_Size(0)
		{
			_Head = BuyNode();
			while (first != last)
			{
				push_back(*first++);
			}
		}
		List(iterator first,iterator last) :_Size(0)
		{
			_Head = BuyNode();
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		//List的拷贝构造函数
		List(List<_Ty> & lt) :_Size(0)
		{
			_Head = BuyNode();
			List<_Ty> tem(lt.begin(), lt.end());

			this->swap(tem);
		}
		//List的析构函数
		~List()
		{
			clear();
			delete _Head;
			_Size = 0;
		}
	protected:
		//申请一个节点
		_Nodeptr BuyNode()
		{
			_Nodeptr _S = new ListNode<_Ty>;
			_S->_Prev = _S->_Next = _S;
			return _S;
		}
	private:
		_Nodeptr  _Head;
		size_t _Size;
	};
}

void main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7,8, 9 ,10};
	MyList::List<int> lt(arr,arr+5);
	MyList::List<int> lt1(lt);
	/*MyList::List<int> lt1(arr+5, arr + 10);*/
	//lt.swap(lt1);
	//MyList::List<int> lt(10);
	//MyList::List<int> lt(10,5);
	lt.insert(lt.end(), 0);
	lt.insert(lt.end(), 1);
	lt.insert(lt.end(), 2);
	lt.insert(lt.end(), 3);
	lt.insert(lt.end(), 4);
	lt.insert(lt.end(), 5);
	//lt.push_back(6);
	//lt.push_front(-1);
	//lt.erase(lt.begin());
	//lt.erase(--lt.end());
	//lt.pop_back();
	//lt.pop_front();
	MyList::List<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	MyList::List<int>::iterator it1 = lt1.begin();
	while (it1 != lt1.end())
	{
		cout << *it1 << " ";
		++it1;
	}
	cout << endl;
	//cout << lt.Back() << endl;
	//cout << lt.Front() << endl;
}
双鱼211
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
C++程序设计 第8周 编程题1# list
beautydakki的博客
01-17 2039
总结的问题： 1. OpenJudge上老师提供的测试数据一共有20万多行，一开始只想着复制粘贴到控制台黑框中，结果电脑内存不够导致粘贴过去的数据不完整。网上搜索“如何输入大量的测试数据”（可能是我的关键字不对），搜索出的结果都不对。突然想起之前有重定向输入输出的课程，翻出来重新学习了一遍，果然找到了很简单的方法。 2. unique函数是去掉连续重复的元素，必须要先排序一遍才能去掉所有的重复
STL的List链表自行实现
11-04
C++中STL的List链表容器的自行实现，自行实现迭代器、类、封装函数等
C++ STL : 模拟实现STL中的list类
凌桓丶的博客
05-27 965
文章目录listlist的介绍list的优缺点list的迭代器失效问题实现的接口节点部分迭代器部分list部分代码实现 list list的介绍 list的文档介绍 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。 list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单
一道经典C++编程题，排序k个排好序的std::list
老宅的虚拟空间
04-27 1752
本文讲述了一道经典算法题：排序k个排好序的list，分析了几种解决办法，并给出了时间复杂度。
C++练习题
qq_43343275的博客
10-10 1058
一 1.写出64位系统环境下，以下数据类型所占字节数 char 1 1 1 char* 4 8 8 int 4 4 4 double 4 8 8 long 8 4 8 long long 8 8 8 unsigned long 8 4 8 err win lin 2.改错 如下程序能不能正确输出，如果不能，让它正确输出hello字符串。 void N...
c模拟c++ stl list
06-18
实现c++ list部分功能，内存自管理 函数的使用和c++ stl list类似，并不完全相同 简单测试过，并不保证完全无错，仅供参考
STL_C++stl实现_
10-01
C++ STL实现包含常用stl模板的手动实现仅供参考
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
11-10
C++ STL--数据结构与算法实现（余文溪）示例程序代码.rar
C++实现STL容器之List
最新发布
04-08
C++实现STL容器之List
STL中list模拟实现源码
08-06
list模拟实现源码，适合初学者学习
c++编程练习 040:List
计算机科学与技术专业学生的成长之路
02-20 1395
北大程序设计与算法（三）测验题汇总(2020春季) 描述 写一个程序完成以下命令： new id ——新建一个指定编号为id的序列(id<10000) add id num——向编号为id的序列加入整数num merge id1 id2——合并序列id1和id2中的数，并将id2清空 unique id——去掉序列id中重复的元素 out id ——从小到大输出编号为id的序列中的元素，以...
C++STL之list的模拟实现
weixin_47257473的博客
02-26 553
STL中list的使用也是和vector的接口类似，可以参考list官方文档本文章主要讲list的模拟实现.list相当于是一个链表，对list操作相当于对链表操作下面是对list的介绍1. list是可以在常数范围内在进行插入和删除的序列式容器，并且该容器可以。2. list的底层结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
【C++STL】list的使用及其模拟实现
qq_67582098的博客
04-03 463
本文介绍了C++ STL中list容器的使用及其模拟实现
List练习题
weixin_67796933的博客
06-24 473
目录​编辑案例:List集合存储学生对象并遍历案例:List集合存储学生对象用三种方式遍历案例：遍历集合 需求:创建一个存储学生对象的List集合,存储三个学生对象,使用程序实现在控制台遍历该集合.思路:程序演示: 案例:List集合存储学生对象用三种方式遍历 需求:创建一个存储学生对象的集合,存储三个学生对象,使用程序实现在控制台遍历该集合。思路：程序演示： 案例：遍历集合 需求：分别使用ArrayList和LinkedList完成存储字符串并遍历 --欢迎大家与我一起交流学习java知识
list集合练习
qq_42058441的博客
05-07 3969
练习1. 1)创建一个ArrayList集合对象，并为这个集合添加元素(元素是Student) 2)采用前面介绍的两种方式获取 M合中的对象 class Student{ String name; int age; double score; } package pro_0416_homework; /** *...
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3131
简易版list模拟实现超详解
21-07-25 用C++的list解决约瑟夫环问题
xngrui的博客
07-25 569
题目： 这题的题目各种各样，有选猴王的，有求幸存者的，总之一致的意思就是：给m个人，围城一个圈，然后从第一个人开始数数，当数到第n个人的时候，这个人就出圈，然后再接着数，数啊数。。。。直到就剩下了一个人，这伙计要么是猴王，要么就是幸存者???? 本题用到的知识点： list，iterator迭代器 我们来分析题目： 1.如何用C++ STL中的list链表组成一个圈？ 把这个链表的首和尾相连就可以。 2.怎样体现首尾相连？ 并不是说我们真的把计算机中的内存地址围城了一个圈，而是当数到list的最后一个数据
c++list容器简单实现排序
GetByteDance的博客
02-06 528
#include<iostream> #include<string> #include<list> using namespace std; class Person { public: Person(string name, int age, int height) { m_Name = name; m_Age = age; m_Height = height; } string m_Name; int m_Age; int m_Height;
c语言 字符串字符反向储存_反向字符串的C ++程序
culing2941的博客
09-10 588
c语言 字符串字符反向储存Here you will get C++ program to reverse a string. 在这里，您将获得C ++程序来反转字符串。 The user is asked to enter a string and then the reverse of the string is displayed. 要求用户输入一个字符串，然后显示该字符串的反面。 ...
C++中STL list的实现
04-05
STL（Standard Template Library）是C++中的一个标准库，其中包含了许多常用的数据结构和算法。其中，list是一种常用的数据结构，它是一个双向链表，可以实现快速的插入和删除操作。 下面是C++中STL list的简单实现： ```cpp template <typename T> class List { private: struct Node { T data; Node* prev; Node* next; Node(const T& d = T(), Node* p = nullptr, Node* n = nullptr) : data(d), prev(p), next(n) {} }; Node* head; Node* tail; int size; public: List() : head(nullptr), tail(nullptr), size(0) {} List(const List& other) : head(nullptr), tail(nullptr), size(0) { for (const auto& item : other) { push_back(item); } } ~List() { clear(); } List& operator=(const List& other) { if (this != &other) { List tmp(other); swap(tmp); } return *this; } void push_back(const T& item) { Node* new_node = new Node(item, tail, nullptr); if (tail) { tail->next = new_node; } else { head = new_node; } tail = new_node; ++size; } void push_front(const T& item) { Node* new_node = new Node(item, nullptr, head); if (head) { head->prev = new_node; } else { tail = new_node; } head = new_node; ++size; } void pop_back() { if (tail) { Node* tmp = tail; tail = tail->prev; if (tail) { tail->next = nullptr; } else { head = nullptr; } delete tmp; --size; } } void pop_front() { if (head) { Node* tmp = head; head = head->next; if (head) { head->prev = nullptr; } else { tail = nullptr; } delete tmp; --size; } } T& front() { return head->data; } T& back() { return tail->data; } bool empty() const { return size == 0; } int size() const { return size; } void clear() { while (!empty()) { pop_back(); } } class iterator { private: Node* ptr; public: iterator(Node* p = nullptr) : ptr(p) {} iterator(const iterator& other) : ptr(other.ptr) {} iterator& operator++() { ptr = ptr->next; return *this; } iterator operator++(int) { iterator tmp(*this); ptr = ptr->next; return tmp; } iterator& operator--() { ptr = ptr->prev; return *this; } iterator operator--(int) { iterator tmp(*this); ptr = ptr->prev; return tmp; } T& operator*() const { return ptr->data; } T* operator->() const { return &(ptr->data); } bool operator==(const iterator& other) const { return ptr == other.ptr; } bool operator!=(const iterator& other) const { return ptr != other.ptr; } }; iterator begin() const { return iterator(head); } iterator end() const { return iterator(nullptr); } iterator rbegin() const { return iterator(tail); } iterator rend() const { return iterator(nullptr); } void swap(List& other) { std::swap(head, other.head); std::swap(tail, other.tail); std::swap(size, other.size); } }; ``` 上述代码中，List类中定义了一个私有结构体Node，它表示双向链表中的每个节点。Node中包含了数据成员data、指向前一个节点的指针prev和指向后一个节点的指针next。List类中还包含了头指针head、尾指针tail和大小size等数据成员。 List类提供了许多操作，包括push_back、push_front、pop_back、pop_front、front、back、empty、size、clear等。其中，push_back和push_front分别表示在双向链表的末尾和开头插入一个元素，pop_back和pop_front分别表示删除双向链表的末尾和开头的元素，front和back分别表示获取双向链表的第一个和最后一个元素，empty表示判断双向链表是否为空，size表示获取双向链表中元素的个数，clear表示清空双向链表中的所有元素。 List类还定义了一个迭代器iterator，它可以用于遍历双向链表中的所有元素。迭代器中包含了一个指向Node的指针ptr，它可以指向双向链表中的任意一个节点。迭代器提供了许多操作，包括++、--、*、->、==、!=等。其中，++和--分别表示迭代器向前和向后移动一个位置，*表示获取迭代器所指向节点的数据成员data，->表示获取迭代器所指向节点的数据成员data的指针，==和!=分别表示判断两个迭代器是否相等和不相等。 List类中还提供了一些其他操作，比如拷贝构造函数、析构函数、赋值运算符、begin、end、rbegin、rend和swap等。其中，拷贝构造函数用于复制另一个List对象，析构函数用于释放所有节点的内存，赋值运算符用于将一个List对象赋值给另一个List对象，begin和end分别返回指向双向链表中第一个元素和最后一个元素的迭代器，rbegin和rend分别返回指向双向链表中最后一个元素和第一个元素的迭代器，swap用于交换两个List对象中的所有数据成员。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值