当前位置： 首页 > article >正文

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

article 2024/12/23 22:53:34

目录

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、接口函数：

迭代器遍历：

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

增删查改：

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的话，那么其迭代器就会失效。

翻转与排序：

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、节点的封装：

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修饰的。

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的几个类型：

	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实现：

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循环遍历一遍的时候，进行尾插即可完成

 

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

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、插入和删除：

//在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即可。

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

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

完整代码：

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


http://www.kler.cn/a/298949.html

相关文章：

  • workman服务端开发模式-应用开发-gateway长链接端工作原理
  • Vue3之状态管理Vuex
  • Leaflet的zoom层级-天地图层级之间的关系
  • C#中方法参数传值和传引用的情况
  • springboot 3 websocket react 系统提示，选手实时数据更新监控
  • python 曲线拟合，曲线拟合交点
  • 通过Python调用Excel VBA宏：扩展自动化能力的深度探索
  • 深入理解java并发编程之aqs框架
  • ABB机器人教程：外部调用例行程序功能介绍与使用方法
  • 流媒体之HLS协议(其三)
  • 动态规划-最长回文子序列
  • Android自动化1️⃣环境搭建【基于Appium】-基于python
  • 在执行django定时任务中，遇到的celery woker生命周期问题
  • 【区块链 + 基层治理】基层党建投票应用“We 投票” | FISCO BCOS应用案例
  • 掌握python-pptx：打造专业PPT表格
  • MIT6.824 课程-GFS
  • PyCharm修改背景颜色、修改字体大小+Python常用快捷键+Python常见的运算符
  • 【PyQt6 应用程序】一键视频解说克隆字幕切割版
  • Linux命令分享 三 （ubuntu 16.04）
  • flink程序 轻松测试
  • 如何在Selenium中捕获网络请求响应
  • 缓存穿透、缓存雪崩、缓存击穿
  • 国产ERT/ECT工业电阻/电容层析成像系统在多相流领域的应用
  • IP地址是怎么实现HTTPS访问的？
  • Vue组件：动态组件、缓存组件、异步组件
  • HarmonyOs 应用基础--Swiper-样式结构重用-GridGridItem