【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的比较：

相关推荐
小俊俊的博客1 小时前
海康RGBD相机使用C++和Opencv采集图像记录
c++·opencv·海康·rgbd相机
_WndProc1 小时前
C++ 日志输出
开发语言·c++·算法
薄荷故人_1 小时前
从零开始的C++之旅——红黑树及其实现
数据结构·c++
m0_748240021 小时前
Chromium 中chrome.webRequest扩展接口定义c++
网络·c++·chrome
qq_433554542 小时前
C++ 面向对象编程：+号运算符重载，左移运算符重载
开发语言·c++
努力学习编程的伍大侠2 小时前
基础排序算法
数据结构·c++·算法
yuyanjingtao2 小时前
CCF-GESP 等级考试 2023年9月认证C++四级真题解析
c++·青少年编程·gesp·csp-j/s·编程等级考试
闻缺陷则喜何志丹3 小时前
【C++动态规划 图论】3243. 新增道路查询后的最短距离 I|1567
c++·算法·动态规划·力扣·图论·最短路·路径
charlie1145141913 小时前
C++ STL CookBook
开发语言·c++·stl·c++20
小林熬夜学编程3 小时前
【Linux网络编程】第十四弹---构建功能丰富的HTTP服务器：从状态码处理到服务函数扩展
linux·运维·服务器·c语言·网络·c++·http
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04解决java读取EXCEL数据变成科学计数法的问题05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明106个主流的工业3D管道设计软件