【C++】list的使用与简单模拟实现

我言秋日胜春朝★2024-09-09 23:09

目录

1、list的介绍和使用：

1、结构：

2、接口函数：

迭代器遍历：

增删查改：

翻转与排序：

2、list的模拟实现：

1、节点的封装：

2、迭代器的封装：

3、list的模拟实现：

1、typedef的几个类型：

2、迭代器的begin和end实现：

3、构造，拷贝构造与析构：

4、插入和删除：

5、其他：

完整代码：

3、vector和list的比较：

1、list的介绍和使用：

1、结构：

对于C++库里面的list是一个双向带头循环链表，双向链表的每个元素存储在不同的独立的节点中，每一个节点通过指针指向前一个节点和后一个节点，其结构如下：

2、接口函数：

迭代器遍历：

cpp 复制代码 
void listtest1()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(2);
	lt.push_back(3);
	lt.push_back(4);
	
	//list<int>::iterator it = lt.begin();
	auto it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
	for (auto e : lt)
	{
		cout << e << " ";
	}
}

增删查改：

cpp 复制代码 
void listtest2()
{
	//创建1234的链表
	list<int> lt; 
	lt.push_back(1); 
	lt.push_back(2); 
	lt.push_back(3); 
	lt.push_back(4);

	lt.push_front(10);
	lt.push_front(20);

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
	//定义迭代器
	list<int>::iterator it = lt.begin();
	
	//在3的前面增加一个30
	it = find(lt.begin(), lt.end(), 3);
	if (it != lt.end())
	{
		lt.insert(it, 30);

		// insert以后，it不失效
	}
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
	//将迭代器找到3的位置
	it = find(lt.begin(), lt.end(),3); 
	//删除3，先判断，在进行删除
	if (it != lt.end())
	{
		lt.erase(it);
	}

	for (auto e : lt)
	{
		cout << e << " ";
	}
}

运行结果：

注意：

在list中，如果进行insert的话，其迭代器是不会失效的，毕竟相对位置没有变，节点之类的也不会变，但是如果进行erase的话，那么其迭代器就会失效。

翻转与排序：

cpp 复制代码 
void listtest3()
{
	list<int> lt;
	lt.push_back(1);
	lt.push_back(3);
	lt.push_back(2);
	lt.push_back(4);

	lt.push_front(20);
	lt.push_front(10);

	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "用算法里面的翻转后：" << endl;
	reverse(lt.begin(), lt.end());
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "用自己容器里面的翻转后：" << endl;
	lt.reverse();
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;

	cout << "排序后：" << endl;
	lt.sort();
	for (auto e : lt)
	{
		cout << e << " ";
	}
	cout << endl;
}

注意：

在上面中，翻转reverse是在list容器与算法库中都存在的，都可以使用，但是排序sort虽然也在list容器与算法库中都存在，但是因为迭代器的性质不一样，所以在算法里面的sort list用不好。

虽然排序都存在，但是list的排序效率比vector低很多，所以如果不嫌麻烦的话可以将list转化为vector然后在进行sort排序，在转化回去。

这个可以向上兼容，比如随机迭代器可以看做特殊的双向或者单向迭代器，所以随机的迭代器可以使用单向或者双向的算法函数。

2、list的模拟实现：

首先，要封装一个节点的结构体和一个迭代器的结构体，需要封装迭代器的结构体是因为要重载*，!=，++等运算符，不然像以前一样直接typedef指针的话，就不是我想要的结果。

1、节点的封装：

cpp 复制代码 
template<class T>
struct list_node
{
	list_node<T>* _next;
	list_node<T>* _prev;
	T _val;

	list_node(const T& val = T())
		:_next(nullptr)
		,_prev(nullptr)
		,_val(val)
	{}
};

直接定义一个结构体，写好构造函数，完成初始化即可。

2、迭代器的封装：

在迭代器的封装中，必须采用3个模版参数，这个是和stl库里面的源码保持一致的，这样的好处是能够在重载运算符的返回值的时候自主地给定是不是需要const修饰的。

cpp 复制代码 
template<class T,class Ref,class Ptr>
struct __list_iterator
{
	typedef list_node<T> Node;
	typedef __list_iterator<T, Ref,Ptr> self;
	Node* _node;

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

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

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

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

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

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

3、list的模拟实现：

在list的模拟实现中，我们定义了两个成员变量，一个是哨兵位的头结点，另一个是这个链表的节点个数。

下面是数个成员函数：

1、typedef的几个类型：

cpp 复制代码 
	typedef list_node<T> Node;
public:
	typedef __list_iterator<T, T&, T*> iterator;
	typedef __list_iterator<T, const T&, const T*> const_iterator;

在上面中，Node是私有的，不希望在类外面被调用的，

另外两个是迭代器，是可以在类外面进行调用的，能够通过迭代器进行遍历使用。

2、迭代器的begin和end实现：

cpp 复制代码 
iterator begin()
{
	return iterator(_head->_next);
}

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

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

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

在上面中，我们通过调用不同的模版来调用const或者非const的迭代器

3、构造，拷贝构造与析构：

首先封装一个empty_init函数来实现初始化，接着在构造函数中直接调用即可，

在拷贝构造函数中先初始化，在用范围for循环遍历一遍的时候，进行尾插即可完成

首先完成链表的清除函数，使这个链表后面的节点全部没有，只剩下一个哨兵位，接着在析构函数中调用清除函数，最后删除哨兵位，置空即可

cpp 复制代码 
void empty_init()
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;

	_size = 0;
}

list()
{
	empty_init();
}

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

	for (auto& e : lt)
	{
		push_back(e);
	}
}


~list()
{
	clear();

	delete _head;
	_head = nullptr;
}

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

4、插入和删除：

cpp 复制代码 
//在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->_next = cur;

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

	++_size;

	return newnode;
}
//删除pos位置的节点,最后返回的是pos位置的下一个节点,注意不能删除哨兵位
//erase存在迭代器失效问题，可以用返回值来解决这个问题
iterator erase(iterator pos)
{
	assert(pos != end());

	Node* cur = pos._node;
	Node* next = cur->_next;
	Node* prev = cur->_prev;

	next->_prev = prev;
	prev->_next = next;

	delete cur;

	--_size;

	return next;
}

在有了插入和删除之后，那些头删之类的就可以直接调用了

5、其他：

最后两个，一个是得到size，就直接通过函数返回size即可。

另一个重载=符号，采用现代写法

cpp 复制代码 
void swap(list<T>& it)
{
	std::swap(_head, it._head);
	std::swap(_size, it._size);
}

list<T>& operator=(list<T> lt)
{
	swap(lt);
	return *this;
}
size_t size()
{
	return _size;
}

完整代码：

cpp 复制代码 
#pragma once
#include<assert.h>

namespace ppr
{
	template<class T>
	struct list_node
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _val;

		list_node(const T& val = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_val(val)
		{}
	};

	template<class T,class Ref,class Ptr>
	struct __list_iterator
	{
		typedef list_node<T> Node;
		typedef __list_iterator<T, Ref,Ptr> self;
		Node* _node;

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

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

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

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

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

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

	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;

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

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

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

		const_iterator end() const
		{
			return const_iterator(_head);
		}
		
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			_size = 0;
		}

		list()
		{
			empty_init();
		}

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

			for (auto& e : lt)
			{
				push_back(e);
			}
		}


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

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

		~list()
		{
			clear();

			delete _head;
			_head = nullptr;
		}

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

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

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

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

		//在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->_next = cur;

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

			++_size;

			return newnode;
		}
		//删除pos位置的节点,最后返回的是pos位置的下一个节点,注意不能删除哨兵位
		//erase存在迭代器失效问题，可以用返回值来解决这个问题
		iterator erase(iterator pos)
		{
			assert(pos != end());

			Node* cur = pos._node;
			Node* next = cur->_next;
			Node* prev = cur->_prev;

			next->_prev = prev;
			prev->_next = next;

			delete cur;

			--_size;

			return next;
		}

		size_t size()
		{
			return _size;
		}
	private:
		Node* _head;
		size_t _size;
	};
}

3、vector和list的比较：

相关推荐
捕鲸叉4 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer4 小时前
【C++】vector 类深度解析：探索动态数组的奥秘
开发语言·c++·算法
Peter_chq4 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
青花瓷5 小时前
C++__XCode工程中Debug版本库向Release版本库的切换
c++·xcode
幺零九零零7 小时前
【C++】socket套接字编程
linux·服务器·网络·c++
捕鲸叉7 小时前
MVC（Model-View-Controller）模式概述
开发语言·c++·设计模式
Dola_Pan8 小时前
C++算法和竞赛：哈希算法、动态规划DP算法、贪心算法、博弈算法
c++·算法·哈希算法
yanlou2338 小时前
KMP算法，next数组详解（c++）
开发语言·c++·kmp算法
小林熬夜学编程8 小时前
【Linux系统编程】第四十一弹---线程深度解析：从地址空间到多线程实践
linux·c语言·开发语言·c++·算法
阿洵Rain8 小时前
【C++】哈希
数据结构·c++·算法·list·哈希算法
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play