list 的实现

已于 2024-05-29 23:54:41 修改
阅读量741 收藏 29
点赞数 14
文章标签： list 数据结构 c++
于 2024-05-29 23:53:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80468112/article/details/139307784
版权

目录

list

结点类

结点类的构造函数

list的尾插尾删

list的头插头删

迭代器

++运算符重载

--运算符重载

==和!= 运算符重载

* 和 -> 运算符重载

 list 的insert

list的erase

list

list实际上是一个带头双向循环链表,要实现list,则首先需要实现一个结点类,而一个结点需要存储的信息为:数据、前驱指针、后继指针

而对于该结点类的成员函数来说,我们只需实现一个构造函数即可,因为该结点类只需要根据数据来构造一个结点即可,而结点的释放则由list的析构函数来完成,

结点类

结点类的基本结构：

	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _date;

		ListNode(const T& pos = T())
		{
			_next = nullptr;
			_prev = nullptr;
			_date = pos;
		}
	};

这里用struct 的原因是因为ListNode 的 每个成员变量都会被频繁调用。

用struct则不需要封装了。

结点类的构造函数

构造函数直接根据所给数据构造一个结点即可,构造出来的结点的数据域存储的就是所给数据,而前驱指针和后继指针均初始化为空指针即可

		ListNode(const T& pos = T())
		{
			_next = nullptr;
			_prev = nullptr;
			_date = pos;
		}

list的尾插尾删

	template<class T>
	class list
	{
	public:
		typedef ListNode<T> node;	
		list()
			:_head(new node)
		{
			_head->_next = _head;
			_head->_prev = _head;
		}
	    void push_back(const T& x)
		{
			node* head = _head;
			node* tail = _head->_prev;
			node* p = new node(x);
			tail->_next = p;
			p->_prev = tail;
			p->_next = head;
			head->_prev = p;
		}

		void pop_back()
		{
			assert(_head != _head->_next);
			node* head = _head;
			node* tail = head->_prev;
			node* newtail = tail->_prev;
			newtail->_next = head;
			head->_prev = newtail;
			delete[] tail;
		}
	private:
		node* _head;
	};

list的头插头删

	template<class T>
	class list
	{

	public:	
		typedef ListNode<T> node;
		list()
			:_head(new node)
		{
			_head->_next = _head;
			_head->_prev = _head;
		}
		void push_front(const T& x)
		{
			node* newnode = new node(x);
			node* head = _head;
			node* tail = _head->_next;
			head->_next = newnode;
			newnode->_prev = head;
			newnode->_next = tail;
			tail->_prev = newnode;
		}

		void pop_front()
		{
			assert(_head != _head->_next);
			node* head = _head;
			node* tail = _head->_next;
			head->_next = tail->_next;
			tail->_next->_prev = head;
			delete[]tail;
		}
	private:
		node* _head;
	};

迭代器

迭代器有两种实现方式,具体应根据容器底层数据结构实现：

  1. 原生态指针,比如：vector和string ->物理空间是连续的，因为string和vector对象都将其数据存储在了一块连续的内存空间,我们通过指针进行自增、自减以及解引用等操作,就可以对相应位置的数据进行一系列操作,因此string和vector当中的迭代器就是原生指针。
  2. .将原生态指针进行封装,因迭代器使用形式与指针完全相同,因此在自定义的类中必须实现以下方法：

指针可以解引用,迭代器的类中必须重载operator*()
指针可以通过->访问其所指空间成员,迭代器类中必须重载oprator->()
指针可以++向后移动,迭代器类中必须重载operator++()与operator++(int)
至于operator--()/operator--(int) 是否需要重载,根据具体的结构来抉择,双向链表可
以向前 移动,所以需要重载,如果是forward_list就不需要重载–
迭代器需要进行是否相等的比较,因此还需要重载operator==()与operator!=()
但是对于list来说,其各个结点在内存当中的位置是随机的,并不是连续的,我们不能仅通过结点指针的自增、自减以及解引用等操作对相应结点的数据进行操作,

总结：list的迭代器 实际上就是对结点指针进行了封装,对其各种运算符进行了重载,使得结点指针的各种行为看起来和普通指针一样,（例如,对结点指针自增就能指向下一个结点 p = p->next）

	template<class T1, class T2>
	struct Reverse_iterator
	{
		typedef Reverse_iterator<T1, T2> self;
		typedef ListNode<T1> node;

		node* _it;

		Reverse_iterator(node* pos)；
		self& operator++()；
		self operator++(int)；
		self& operator--()；
		self operator--(int)；
		T2& operator*()；
		T2* operator->()；
		bool operator!=(const self& pos)；
		bool operator==(const self& pos)；

    }；

迭代器模板参数说明：

构造函数
迭代器类实际上就是对结点指针进行了封装

其成员变量就是结点指针,所以其构造函数直接根据所给结点指针构造一个迭代器对象即可,

		Reverse_iterator(node* pos)
		{
			_it = pos;
		}

拷贝构造,operator,析构函数我们都不需要写,因为成员变量是内置类型(指针), 用编译器默认生成的就可以。

++运算符重载

		self& operator++()//前置
		{
			_it =_it->_prev;
			return *this;
		}

		self operator++(int)//后置
		{
			self tmp(_it);
			_it = _it->_prev;
			return tmp;
		}

前置++原本的作用是将数据自增,然后返回自增后的数据,

而对于结点迭代器的前置++:应该先让结点指针指向后一个结点.然后再返回“自增”后的结点迭代器即可

后置++,先拷贝构造当前迭代器结点, 然后让当前迭代器结点的指针自增指向下一个结点,最后返回“自增”前的结点迭代器即可,

--运算符重载

		self& operator--()//前置
		{
			_it = _it->_next;
			return *this;
		}

		self operator--(int)//后置
		{
			self tmp(_it);
			_it = _it->_next;
			return tmp;
		}

前置- -：当前迭代器结点中的指针指向前一个结点,然后再返回“自减”后的结点迭代器即可,

后置--：拷贝构造当前迭代器对象 -> 当前迭代器结点中的指针自减指向前一个结点 ->返回自减前的迭代器。

==和!= 运算符重载

		bool operator!=(const self& pos)
		{
			return _it != pos._it;
		}

		bool operator==(const self& pos)
		{
			return _it == pos._it;
		}

这里注意形参别写错就好了。

* 和 -> 运算符重载

使用解引用操作符时,是想得到该指针指向的数据内容

因此,我们直接返回当前结点指针所指结点的数据即可,这里需要使用引用返回,因为解引用后可能需要对数据进行修改,

		T2& operator*()
		{
			return _it->_date;
		}

->返回当前迭代器结点的指针所指结点的数据的地址

		T2* operator->()
		{
			return &_it->_date;
		}

使用场景：

 list 的insert

insert函数可以在所给迭代器pos之前插入一个新结点,

1.先根据所给迭代器pos得到该位置处的结点指针

2.然后通过该指针找到前一个位置的结点指针last

根据所给数据x构造一个新结点

		iterator insert(iterator pos,const T& x)
		{
			node* newnode = new node(x);
			node* next = pos._node;
			node* last = next->_prev;
			last->_next = newnode;
			newnode->_prev = last;
			newnode->_next = next;
			next->_prev = newnode;
			return iterator(newnode);
		}

list的erase

erase函数可以删除所给迭代器位置的结点,

注意**:pos不可以是哨兵位的迭代器,即不能删除哨兵位 pos迭代器结点中的指针不能为空**

1.根据所给迭代器得到该位置处的结点指针self

2.通过self指针找到前一个位置的结点指针last,以及后一个位置的结点指针next

3.紧接着释放cur结点,最后prev和next结点进行链接

		iterator erase(iterator pos)
		{
			assert(pos._node);
			assert(_head != _head->_next);
			node* self = pos._node;
			node* next = self->_next;
			node* last = self->_prev;
			last->_next = next;
			next->_prev = last;
			delete[] self;
			return iterator(next);
		}

关于insert 和 erase 迭代器失效的问题：

insert不会导致迭代器失效,因为pos迭代器中的节点指针仍然指向原来的节点。

问:erase之后, pos迭代器是否失效：
一定失效,因为此时pos迭代器中的节点指针指向的节点已经被释放了,该指针相当于是野指针。

 最后所有代码如下：
 

namespace bit
{
	template<class T>
	struct ListNode
	{
		ListNode<T>* _next;
		ListNode<T>* _prev;
		T _date;

		ListNode(const T& pos = T())
		{
			_next = nullptr;
			_prev = nullptr;
			_date = pos;
		}
	};

	template<class T1,class T2 = T1>
	struct ListIterator
	{
		typedef ListIterator<T1,T2> iterator;
		typedef ListNode<T1> node;
		node* _node;

		ListIterator(node* pos)
		{
			_node = pos;
		}

		T2& operator*()
		{
			return _node->_date;
		}

		iterator& operator++()
		{
			_node = _node->_next;
			return *this;
		}		

		iterator operator++(int)
		{
			iterator tmp(_node);
			_node = _node->_next;
			return tmp;
		}

		iterator& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		iterator operator--(int)
		{
			iterator tmp(_node);
			_node = _node->_prev;
			return tmp;
		}

		T2* operator->()
		{
			return &_node->_date;
		}

		bool operator!=(const iterator& pos)
		{
			return _node != pos._node;
		}

		bool operator==(const iterator& pos)
		{
			return _node == pos._node;
		}
	};

	template<class T1, class T2>
	struct Reverse_iterator
	{
		typedef Reverse_iterator<T1, T2> self;
		typedef ListNode<T1> node;

		node* _it;

		Reverse_iterator(node* pos)
		{
			_it = pos;
		}

		self& operator++()
		{
			_it =_it->_prev;
			return *this;
		}

		self operator++(int)
		{
			self tmp(_it);
			_it = _it->_prev;
			return tmp;
		}

		self& operator--()
		{
			_it = _it->_next;
			return *this;
		}

		self operator--(int)
		{
			self tmp(_it);
			_it = _it->_next;
			return tmp;
		}

		T2& operator*()
		{
			return _it->_date;
		}

		T2* operator->()
		{
			return &_it->_date;
		}

		bool operator!=(const self& pos)
		{
			return _it != pos._it;
		}

		bool operator==(const self& pos)
		{
			return _it == pos._it;
		}
	};

	template<class T>
	class list
	{

	public:
		typedef Reverse_iterator<T, T> reverse_iterator;
		typedef Reverse_iterator<T, const T> const_reverse_iterator;
		typedef ListNode<T> node;
		typedef ListIterator<T> iterator;
		typedef ListIterator<T,const T> const_iterator;
		list()
			:_head(new node)
		{
			_head->_next = _head;
			_head->_prev = _head;
		}

		list(const list& pos)
		{
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;
			for (auto e : pos)
			{
				push_back(e);
			}
		}

		list(initializer_list<T> il)
		{
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;
			for (auto e : il)
			{
				push_back(e);
			}

		}

		void push_back(const T& x)
		{
			node* head = _head;
			node* tail = _head->_prev;
			node* p = new node(x);
			tail->_next = p;
			p->_prev = tail;
			p->_next = head;
			head->_prev = p;
		}

		void pop_back()
		{
			assert(_head != _head->_next);
			node* head = _head;
			node* tail = head->_prev;
			node* newtail = tail->_prev;
			newtail->_next = head;
			head->_prev = newtail;
			delete[] tail;
		}

		reverse_iterator rbegin()
		{
			return reverse_iterator(_head->_prev);
		}

		reverse_iterator rend()
		{
			return reverse_iterator(_head);
		}

		const_reverse_iterator crbegin()const
		{
			return const_reverse_iterator(_head->_prev);
		}

		const_reverse_iterator crend()const
		{
			return const_reverse_iterator(_head);
		}


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

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

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

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

		void push_front(const T& x)
		{
			node* newnode = new node(x);
			node* head = _head;
			node* tail = _head->_next;
			head->_next = newnode;
			newnode->_prev = head;
			newnode->_next = tail;
			tail->_prev = newnode;
		}

		void pop_front()
		{
			assert(_head != _head->_next);
			node* head = _head;
			node* tail = _head->_next;
			head->_next = tail->_next;
			tail->_next->_prev = head;
			delete[]tail;
		}

		iterator insert(iterator pos,const T& x)
		{
			node* newnode = new node(x);
			node* next = pos._node;
			node* last = next->_prev;
			last->_next = newnode;
			newnode->_prev = last;
			newnode->_next = next;
			next->_prev = newnode;
			return iterator(newnode);
		}

		iterator erase(iterator pos)
		{
			assert(pos._node);
			assert(_head != _head->_next);
			node* self = pos._node;
			node* next = self->_next;
			node* last = self->_prev;
			last->_next = next;
			next->_prev = last;
			delete[] self;
			return iterator(next);
		}

		~list()
		{
			iterator it1 = begin();
			while (it1 != end())
			{
				it1 = erase(it1);
			}
			delete _head;
			_head = nullptr;
		}

	private:
		node* _head;
	};

fy zs
关注
  • 14
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hive的collect_list实现全局有序
nefu_zjh的博客
07-25 9256
关于Hive中的collect_list实现全局有序简单说Hive再来说collect_list()collect_list()能干啥使用collect_list()实现全局排序 简单说Hive Hadoop的logo是一只大象，从Hive的logo看，它是一个具有大象头，蜜蜂身体的这么一个玩意，旨在给这只庞大的大象瘦身。所以它以一种HiveQL的方式取代了传统通过MR去离线计算HDFS上面的那些文件，为开发者省去了很多复杂代码的开发，其学习成本也更低 Hive提供了一些现成的函数，让开发者可以调用。整体
java使用list实现数据库的like功能
09-04
在Java编程中，使用List实现数据库的“LIKE”功能，主要是为了模拟数据库中的模糊查询操作。这个功能在处理大量数据时非常有用，尤其是当用户输入的部分关键词需要匹配数据库中对应的字段时。下面将详细解释如何使用...
redis list 实现消息队列 多线程消费
qq_17586173的博客
12-07 4968
redis list 实现消息队列 多线程消费
List实现反转
热门推荐
这个杀手不太累的博客
11-03 3万+
方法一：使用Collections.reverse()方法反转 方法二：自己迭代list实现反转 import java.util.ArrayList; import java.util.Collections; import java.util.List;public class Test { public static void main(String[] args) {
java的list实现分组求和
yang_best的专栏
07-20 1万+
对list的数据按某些属性进行分组，然后对组内某些属性求和，类似sql的group by功能。 例如以下以机构和客户号组合分组，对debt求和，最后形成一个新的list public static void main(String[] args) { DebtCust d1 = new DebtCust().setDeptId(1L).setCustCode("1").setDebt(new BigDecimal("5.1")); DebtCust d2 = new.
Redis系列学习文章分享---第七篇（Redis快速入门之消息队列--List实现消息队列 Pubsub实现消息队列 stream的单消费模式 stream的消费者组模式 基于stream消息队列）
weixin_44976692的博客
03-19 1万+
消息队列是一种在应用程序之间传递消息的通信方式。它通常用于解耦消息的发送者和接收者，提高系统的可靠性、扩展性和性能。本文介绍了Redis消息队列的基本概念和常见实现方式，并通过示例代码演示了如何使用Redis Stream实现消息队列。希望本文能够帮助您更好地理解和应用Redis消息队列技术。
Flutter中的List实现深拷贝deepcopy
lvsonghai的博客
05-17 4648
Flutter中的List实现深拷贝deepcopy 问题描述 项目中曾遇到这样的问题，在网络请求回来的分类数据类型为Map< String, List< String>>,暂且称之为_categoryMap；然后点击不同的按钮就把_categoryMap中的 List< String> 数据复制给另外一个List对象，称之为_list1;在赋值之前会先对_list1中的数据执行一次清空操作“_list1.clear();”。 这时候问题就来了，数据为空导致Flutter
Java中List实现分组求和的例子
百木成林
12-17 9989
功能类似sql的 sum  group by的用法，示例如图
List接口及其实现类
yanyangjun6的博客
11-19 3428
1：List接口常用实现类的对比 1.1: 2：ArrayList源码分析 3：LinkedList源码分析 4：Vector源码分析 5：List接口中的常用方法 文章目录1：List接口常用实现类的对比1.1:2：ArrayList源码分析3：LinkedList源码分析4：Vector源码分析5：List接口中的常用方法 ...
使用 redis list 实现滑动窗口
IT民工的博客
09-24 5147
redis-list添加多个对象进入一个 list lpush test 0 1 2 3 4 5 6 7 8 9 10 11 12 13 列出list中所有的对象lrange test 0 -1ltrim test 0 9截断列表 ，保留10个对象
Python列表list底层源码实现及解析
在上树的路上的博客
03-31 7507
1.创建list Python底层是用C写的，因此列表在底层相当结构体变量，主要源码如下所示（实际上会有很多东西，后续的源码同理）。 前面之所以有两个指针，是因为一个list对象相当于双向链表中的一个节点，需要前指针和后指针进行相连。 下面是创建list的源码，注意返回值是一个指针，这意味着我们定义一个列表a = []，a中实际存的是
在.net中用CheckBoxList实现单选
10-26
`RadioButtonList`控件是.NET Framework中用于实现单选功能的标准控件，但有时开发者可能会选择使用`CheckBoxList`来达到类似的效果，主要是出于视觉上的偏好。本篇文章将探讨如何在.NET中使用`CheckBoxList`控件...
C# List实现行转列的通用方案
08-31
C# List实现行转列的通用方案 本文将介绍使用C# List实现行转列的通用方案，通过使用System.Linq.Dynamic动态LINQ库来完成行转列功能，并且介绍了过滤功能，具有很好的参考价值。 1. 行转列的需求分析 在报表统计...
Duilib实现List列表
01-27
由VS20013 + Duilib实现，想对List控件研究的可以一起学习下，UI界面链接地址：https://blog.csdn.net/u012983289/article/details/122718229
STL -list实现02
04-24
STL list实现02，其他容器的实现，依次类推。看不懂的C基础太差，别想C++某些原理了
Java数据结构-链表与LinkedList
daweidi的博客
07-11 711
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。LinkedList实现了List接口。LinkedList没有实现RandomAccess接口，因此不支持随机访问。LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O（1）方法解释尾插 e将 e 插入到 index 位置尾插 c 中的元素删除 index 位置元素。
Java链表LinkedList经典题目
最新发布
lllsure的博客
07-11 567
既然用不了，那我们就借着这个思路改一下，给短的链表补上不就行了，换句话说，链表从后往前对齐，长链表前面多的那部分不可以有结点，直接跳过即可，这样问题就解决了。定义三个ListNode变量指向三个节点，cur指向的是当前要改变next的节点，pr指向的是cur.next要指向的节点，p是记录的作用，如果cur的next变成指向前面了，那么本来cur后面一个节点就丢失了，无法完成反转。应用的也是快慢指针的思想，这个就像在操场上跑步一样，如果一快一慢，而且还是闭环的话，那么两个人一定会相遇。
ProFormList --复杂数据联动ProFormDependency
qq_48691693的博客
07-08 191
ProFormList --复杂数据联动ProFormDependency、自定义操作按钮、禁用当前行
Redis数据结构详解：String、List、Set、Hash和Sorted Set
Cao_shuqi的博客
07-09 914
String 是 Redis 最基本的数据类型，一个键对应一个值，值可以是字符串、整数或浮点数。String 类型是二进制安全的，意味着可以存储任何类型的数据，如文本、图片序列化后的数据等。List 是一个有序的字符串链表，允许在链表的两端推入和弹出元素。它支持从左侧（头部）和右侧（尾部）进行插入和删除操作。List 可以用于实现诸如消息队列等功能。Set 是一个无序集合，包含唯一的字符串元素。Set 的主要功能是去重，它适合用于需要去重的场景，如统计唯一访客。Hash 是一个键值对集合，适合用于存储对象。
java list实现
10-10
Java中的List是一个接口，它提供了有序、可重复的集合，它的实现类有ArrayList、LinkedList等。这些实现类都可以存储任何类型的对象，而且可以动态扩展。 ArrayList是基于动态数组实现的，它可以随机访问元素，但是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值