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

news2024/9/21 4:29:54

目录

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.coloradmin.cn/o/2111724.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Flutter中自定义气泡框效果的实现

Flutter中自定义气泡框效果的实现

在用户界面的设计中&#xff0c;气泡框&#xff08;Bubble&#xff09;是一种非常有效的视觉工具&#xff0c;它可以用来突出显示信息或提示用户。气泡框广泛应用于聊天应用、通知提示等场景。在 Flutter 中&#xff0c;虽然有很多现成的气泡框组件&#xff0c;但如果你想要更多…
阅读更多...
关于 ubuntu系统install的cmake版本较低无法编译项目升级其版本 的解决方法

关于 ubuntu系统install的cmake版本较低无法编译项目升级其版本 的解决方法

若该文为原创文章&#xff0c;转载请注明原文出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/141933927 长沙红胖子Qt&#xff08;长沙创微智科&#xff09;博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV…
阅读更多...
django摄影竞赛小程序论文源码调试讲解

django摄影竞赛小程序论文源码调试讲解

2系统关键技术及工具简介 系统开发过程中设计的关键技术是系统的核心&#xff0c;而开发工具则会影响的项目开发的进程和效率。第二部分便描述了系统的设计与实现等相关开发工具。 2.1 Python简介 Python 属于一个高层次的脚本语言&#xff0c;以解释性&#xff0c;编译性&am…
阅读更多...
Android Studio调试Flutter项目

Android Studio调试Flutter项目

run运行项目中途&#xff0c;点击Flutter Attach 等一会就可以调试&#xff01; 或者&#xff0c;直接Debug允行项目。
阅读更多...
C++相关概念和易错语法（32）（单例模式、类型转换）

C++相关概念和易错语法（32）（单例模式、类型转换）

1.单例模式 &#xff08;1&#xff09;设计模式是什么&#xff1f; 简单来说&#xff0c;被反复使用&#xff0c;多数人知晓、经过分类的代码设计经验的总结就叫设计模式&#xff0c;它建立在特殊类的设计之上&#xff0c;实现特殊的功能&#xff0c;运用的知识也十分综合。如…
阅读更多...
协议集合（学习笔记）

协议集合（学习笔记）

按照数据的传送方式&#xff0c;通信协议可分为以下2种。 串行通信&#xff1a;串行&#xff08;Serial&#xff09;指的是逐个传输数据位&#xff0c;一次只传输一个位。 并行通信&#xff1a;并行&#xff08;Parallel&#xff09;指的是同时传输多个数据位&#xff0c;一次…
阅读更多...
VMware 中 kali Linux的安装与使用

VMware 中 kali Linux的安装与使用

文章目录 前言 一、安装虚拟机 二、使用步骤 总结 前言 随着信息技术的飞速发展&#xff0c;虚拟化技术已经成为现代企业和个人用户不可或缺的一部分。通过虚拟化技术&#xff0c;我们可以在一台物理计算机上运行多个独立的操作系统和应用程序&#xff0c;从而实现资源的高效利…
阅读更多...
基于WiFi的智能照明控制系统的设计与实现（论文+源码）

基于WiFi的智能照明控制系统的设计与实现（论文+源码）

1系统方案设计 本设计智能照明控制系统&#xff0c;结合STM32F103单片机、光照检测模块、显示模块、按键模块、太阳能板、LED灯模块、WIFI模块等器件构成整个系统&#xff0c;在功能上可以实现光照强度检测&#xff0c;并且在自动模式下可以自动调节照明亮度&#xff0c;在手动…
阅读更多...
【spring】例子2：mvc web开发

【spring】例子2：mvc web开发

领域类 开发时编译时用lombok提供支持 最终生成的包里不包含lombok
阅读更多...
【Android】程序开发组件—探究Jetpack

【Android】程序开发组件—探究Jetpack

引言 Jetpack是一个开发组件工具集&#xff0c;它的主要目的是帮助我们编写出更加简洁的代码&#xff0c;并简化我们的开发过程&#xff0c;在这么多的组件当中&#xff0c;最需要我们关注的其实还是架构组件&#xff0c;接下来就对Jetpack的主要架构组件进行学习&#xff01;…
阅读更多...
数据结构-----栈、队列

数据结构-----栈、队列

一、栈 1、栈(stack)是限定仅在表尾进行插入和删除操作的线性表。 把允许插入和删除的一端称为栈顶&#xff08;top)&#xff0c;另一端称为栈底&#xff08;bottom)&#xff0c;不含任何数据元素的栈称为空栈。栈又称为后进先出&#xff08;Last In First Out)的线性表,简称L…
阅读更多...
OpenAI gym: Trouble installing Atari dependency (Mac OS X)

OpenAI gym: Trouble installing Atari dependency (Mac OS X)

题意&#xff1a; 使用OpenAI Gym库时&#xff0c;安装Atari环境可能会遇到一些依赖问题&#xff0c;尤其是在Mac OS X系统上 问题背景&#xff1a; Im new to OpenAI gym. Ive successfully installed OpenAI gym on my Mac OS X (High Sierra 10.13.3) laptop and made a D…
阅读更多...
C语言程序设计(算法的概念及其表示)

C语言程序设计(算法的概念及其表示)

一、算法的概念 一个程序应包括两个方面的内容： 对数据的描述：数据结构 对操作的描述：算法 著名计算机科学家沃思提出一个公式： 数据结构 ＋算法 ＝程序 完整的程序设计应该是： 数据结构＋算法＋程序设计方法＋语言工具 广义地说，为解决一个问题而采取的方法和步骤…
阅读更多...
学不会虚拟列表?10分钟带你实现高度固定的Vue虚拟列表方案及原理

学不会虚拟列表?10分钟带你实现高度固定的Vue虚拟列表方案及原理

前言 本文主要介绍长列表的一种优化方案&#xff1a;虚拟列表。本文主要是对传统的虚拟列表方案进行更加详尽的刨析&#xff0c;以便我们能够更加深入理解虚拟列表的原理。 虚拟列表目录 1、为什么需要使用虚拟列表2、什么是虚拟列表与懒加载的区别(重要) 3、实现思路4、通过节…
阅读更多...
企业选ETL还是ELT架构？

企业选ETL还是ELT架构？

作为数据处理的重要工具&#xff0c;ETL工具被广泛使用&#xff0c;同时ETL也是数据仓库中的重要环节。本文将从解释ETL工具是怎么处理数据&#xff0c;同时介绍ELT和ETL工具在企业搭建数据仓库的重要优势。 一、什么是ETL? ETL是Extract-Transform-Load的缩写&#xff0c;将…
阅读更多...
【深度学习】多层感知机的从零开始实现与简洁实现

【深度学习】多层感知机的从零开始实现与简洁实现

可以说&#xff0c;到现在我们才真正接触到深度网络。最简单的深度网络称为多层感知机。 多层感知机由多层神经元组成&#xff0c;每一层与它的上一层相连&#xff0c;从中接收输入&#xff1b;同时每一层也与它的下一层相连&#xff0c;影响当前层的神经元。 和以前相同&…
阅读更多...
【深入解析】AI工作流中的HTTP组件：客户端与服务端执行的区别

【深入解析】AI工作流中的HTTP组件：客户端与服务端执行的区别

在当今快速发展的技术环境中&#xff0c;AI工作流的设计和实现变得愈发重要。尤其是在处理HTTP组件时&#xff0c;前端执行与后端执行之间的区别&#xff0c;往往会对系统的安全性和数据的准确性产生深远的影响。今天&#xff0c;我们就来深入探讨这一话题&#xff0c;揭示前端…
阅读更多...
音频基础学习四——声音的能量与分贝

音频基础学习四——声音的能量与分贝

文章目录 前言一、能量与分贝1.音频能量2.分贝3.两者的区别4. 应用场景 二、分贝的计算方式1.具体数学公式2.具体算法示例3.对于算法的释义大小端为什么通过计算得到的是负值范围实际结果 总结 前言 很多博客中经常会把声音的能量和分贝说成是一个东西&#xff0c;这种说法是错…
阅读更多...
原型模式prototype

原型模式prototype

此篇为学习笔记&#xff0c;原文链接 https://refactoringguru.cn/design-patterns/prototype 能够复制已有对象&#xff0c; 而又无需使代码依赖它们所属的类 所有的原型类都必须有一个通用的接口&#xff0c; 使得即使在对象所属的具体类未知的情况下也能复制对象。 原型对…
阅读更多...
云计算之云原生（上）

云计算之云原生（上）

目录 一、消息队列RocketMQ 1.1 功能介绍 1.1.1 业务消息首选&#xff1a;消息队列 RocketMQ 1.1.2 【收发流量隔离约束】读写分离控制提高集群稳定性 1.1.3 【Dashboard 仪表盘】实时观测实例状态 1.1.4 【消息轨迹追踪】消息生命周期状态一目了然 1.1.5 【实时扩缩容】…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023