List的模拟实现

最新推荐文章于 2024-04-30 15:47:10 发布
最新推荐文章于 2024-04-30 15:47:10 发布
阅读量491 收藏
点赞数
分类专栏： C++ 文章标签： list 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ds19415169988/article/details/121295081
版权

List.h

#pragma once
#include<assert.h>
namespace bit
{
	template<class T>
	struct __list_node
	{
		__list_node<T>* _next;
		__list_node<T>* _prev;
		T _data;
		//构造函数，new node需要
		__list_node(const T& x = T())//没有传参就可以调用，当没有传参的时候就应该使用缺省值
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
	};
	// 迭代器-- 用一个类去封装了节点的指针
	//类能运算符重载--实现指针(迭代器)
	//List不能使用原生的指针(地址不连续)了得自己实现
	template<class T, class Ref, class Ptr>//里面使用的Node使用类模板，所以这里也要是类模板
	struct __list_iterator//类
	{
	   //这段代码能实现test_List中需要find的时候出错
	   //typedef bidirectional_iterator_tag iterator_category;
		//typedef T value_type;
		//typedef Ptr pointer;
		//typedef Ref reference;
		//typedef ptrdiff_t difference_type;
	
		typedef __list_iterator<T, Ref, Ptr> self;
		typedef __list_node<T> Node;
		Node* _node;
		//构造函数
		__list_iterator(Node* node)
			:_node(node)
		{}
		//重载*--解引用返回里面的数据
		// *it -> it.operator*()
		//可读可写 *it=10
		Ref operator*()//返回的是data的指针
		{
			return _node->_data;
		}
		Ptr operator->()
		{
			return &_node->_data;
		}
		//重载++， ++it
		// ++it-> it.operator++()
		self& operator++()
		{
			_node = _node->_next;
			return *this;//前置++返回++以后的值
		}
		// it++ -> it.operator++(0)
		self operator++(int)//不能用引用tmp出作用域后会非法，这里传值会拷贝
		{
			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);
		}
		//end为最后一个节点的下一个位置
		iterator end()
		{
			return iterator(_head);
		}
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
		}
		const_iterator end() const
		{
			return const_iterator(_head);
		}
		list()
		{
			// 带头双向循环
			//_head = new Node(T());//因为T()不知道类型，所以不能传0，传T类型的匿名对象
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		//深拷贝
		// lt2(lt1) -- 传统写法
		/*list(const list<T>& lt)
		{
		_head = new Node;
		_head->_next = _head;
		_head->_prev = _head;

		for (const auto& e : lt)//要加引用万一T为String类型则为深拷贝用引用更好
		{
		push_back(e);
		}
		}*/
		template<class InputIterator>//模板
		list(InputIterator first, InputIterator last)//支持所有类型的迭代器来初始化
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}
		// lt2(lt1) -- 现代写法
		list(const list<T>& lt)
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;

			list<T> tmp(lt.begin(), lt.end());
			std::swap(_head, tmp._head);
		}
		//赋值
		// lt1 = lt4  -- 传统写法
		/*list<T>& operator= (const list<T>& lt)
		{
		if (this != &lt)
		{
		clear();
		for (const auto& e : lt)
		{
		push_back(e);
		}
		}
		return *this;
		}*/

		// lt1 = lt4 -现代写法
		list<T>& operator= (list<T> lt)//这里赋值用的是传值
		{
			swap(_head, lt._head);
			return *this;
		}
		//把所有的数据清理掉，但不清理头结点，清理后还可以再插入
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}
		//尾插
		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());
		}
	   iterator insert(iterator pos, const T& x)
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* newnode = new Node(x);

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			//iterator ret(newnode);
	    	//return ret;
			return iterator(newnode);
			//return newnode;
		}
	   //类模板中的成员函数是按需实例化，调用了哪个成员函数，就实例化哪个
	   //按需实例化--assert不写头文件在普通的erase可能不报错，但是clear调用erase没有头文件就会报错
	   //函数模板
		iterator erase(iterator pos)
		{
			//不能删头结点--end为最后一个节点的下一个数据即头结点
			assert(pos != end());
			Node* cur = pos._node;
			//找到要删节点的前后节点，然后再删除此节点，此节点的前后节点连接即可
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			prev->_next = next;
			next->_prev = prev;
			//follow刚刚被删除那个节点
			return iterator(next);
		}
		//求size--O(n)的接口少使用
		size_t size()
		{
			size_t n = 0;
			iterator it = begin();
			while (it != end())
			{
				++it;
				++n;
			}
			return n;
		}
		bool empty()
		{
			return begin() == end();//head->next=head
		}
	private:
		Node* _head;
	};
	//需要const迭代器--const对象
	void print_list(const list<int>& l)
	{
		list<int>::const_iterator it = l.begin();
		while (it != l.end())
		{
			//*it += 1;--err,const迭代器的不能修改
			cout << *it << " ";
			++it;
		}
		cout << endl;
	  }
	void test_list1()
	{
		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();
		while (it != lt.end())
		{
			//it.operator*() = 10;
			//*it = 10;
			cout << *it << " ";
			++it;
		}
		cout << endl;
		for (auto e : lt)
		{
			cout << e << " ";
		}
		cout << endl;
	}
    //树--自定义类型
	struct TreeNode
	{
		struct TreeNode* _left;
		struct TreeNode* _right;
		int _val;

		TreeNode(int val = -1)
			:_left(nullptr)
			, _right(nullptr)
			, _val(val)
		{}
	};
	//ostream& operator<<(ostream& out, TreeNode n);
	void test_list2()
	{
		list<TreeNode> lt;
		lt.push_back(TreeNode(1));
		lt.push_back(TreeNode(2));
		lt.push_back(TreeNode(3));
		lt.push_back(TreeNode(4));

		list<TreeNode>::iterator it = lt.begin();
		while (it != lt.end())
		{
			//cout << (*it)._val << " ";
			//结构体打印的方法-->用点，（*it）即it.Operator*()
			printf("val:%d,left:%p,right:%p\n", (*it)._val, (*it)._left, (*it)._right);
			//在前面重载Operator->就能使用，返回的是operator的指针,重载operator->用的是Ptr，ptr对应的是T*所以返回的是指针
			printf("val:%d,left:%p,right:%p\n", it->_val, it->_left, it->_right);
			++it;
		}
		cout << endl;
	}
	void test_list3()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);

		print_list(lt);
		lt.clear();
		print_list(lt);

		lt.push_back(10);
		lt.push_back(20);
		lt.push_back(30);
		print_list(lt);
	}
	void test_list4()
	{
		list<int> lt1;
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(3);
		lt1.push_back(4);
		for (auto e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;
		list<int> lt2(lt1);
		for (auto e : lt2)
		{
			cout << e << " ";
		}
		cout << endl;
		//拷贝构造
		list<int> lt3(lt1.begin(), lt1.end());
		for (auto e : lt3)
		{
			cout << e << " ";
		}
		cout << endl;
		string s("hello");
		list<int> lt4(s.begin(), s.end());
		for (auto e : lt4)
		{
			cout << e << " ";
		}
		cout << endl;
		//赋值
		lt1 = lt4;
		for (auto e : lt1)
		{
			cout << e << " ";
		}
		cout << endl;
	}
	// int* p       *p
	// TreeNode* p  p->_val
}

test.c

#include <iostream>
#include <list>
#include <vector>
#include <algorithm>
#include <functional>
#include <time.h>
using namespace std;
#include "List.h"
int main()
{
	bit::test_list1();
	//bit::test_list2();
	//bit::test_list3();
	//bit::test_list4();
	return 0;
}

insert

在这里插入图片描述

迭代器

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

迭代器需不需要实现析构、拷贝构造、赋值重载

  • 不需要默认生成就好了
  • 因为节点属于链表的，不是迭代器的，节点不需要迭代器来析构，而是链表自己析构
  • 默认为浅拷贝

Test_List1()

在这里插入图片描述

Test_List2()

在这里插入图片描述
在这里插入图片描述

Test_List3()

在这里插入图片描述

Test_List4()

  • 迭代器默认为浅拷贝，但是list得自己写深拷贝不然会因为浅拷贝而报错
    在这里插入图片描述
    在这里插入图片描述
入木
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL中list模拟实现源码
08-06
list模拟实现源码，适合初学者学习
C++list类的模拟实现
代码笔记本
01-26 694
本文是对之前list类的模拟实现的重制。 文章目录整体框架Alloc内存池iterator类iterator的意义iterator的实现operator=&&拷贝析构iterator的三个模板参数operator->的编译器省略List的拷贝构造析构等list接口的基本实现string，vector，list的迭代器 整体框架 namespace YCB { //模拟实现list当中的结点类 template<class T> struct _list_node {
PTA:7-87 集合的模拟实现（类模板）
Sy_Faker的博客
04-12 1045
我们可以用一个类来模拟集合及集合运算，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用类模板实现集合及集合运算，包括集合元素的增加、删除和查找的等基本功能。 集合模板类MySet包括数据如下： ...
PTA 集合的模拟实现（类模板）
outsiderJT的博客
05-25 916
题目： 我们可以用一个类来模拟集合及集合运算，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用类模板实现集合及集合运算，包括集合元素的增加、删除和查找的等基本功能。 集合模板类MySet包括数据如下： T data[100];//用数组来存放所有的集合元素，最多不超过100个元素 int count;//
PTA 7-4 集合的模拟实现（类模板） (40分) c++
qq_40468936的博客
05-15 1435
我们可以用一个类来模拟集合及集合运算，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用类模板实现集合及集合运算，包括集合元素的增加、删除和查找的等基本功能。 集合模板类MySet包括数据如下： T data[100];//用数组来存放所有的集合元素，最多不超过100个元素 int count;//表示目前
C++模拟实现list
03-11
C++模拟实现list
List各个接口模拟实现
08-27
List各个接口模拟实现
C++ 模拟实现list(迭代器)实现代码
08-30
主要介绍了C++ 模拟实现list(迭代器)实现代码的相关资料,需要的朋友可以参考下
集合的模拟实现（类模板）
Jumping_mermaid的博客
06-29 2692
我们可以用一个类来模拟集合及集合运算，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用类模板实现集合及集合运算，包括集合元素的增加、删除和查找的等基本功能。 集合模板类MySet包括数据如下：
C++——list的模拟实现
qq_56663697的博客
11-18 815
文章目录接口总览list结点的模拟实现list迭代器的模拟实现迭代器类的模板参数说明构造函数++运算符的重载- - 运算符的重载==运算符的重载!=运算符的重载*运算符的重载list的模拟实现默认成员函数构造函数迭代器相关函数 接口总览 namespace NZB { // 模拟实现list结点 template<class T> struct _list_node { _list_node(const T& val = T()); // 构造结点 //成员变量 T
PTA:7-86 集合的模拟实现（函数模板）
Sy_Faker的博客
04-12 541
我们可以用一个数组来模拟集合，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用模板函数实现集合元素的增加、删除和查找功能。 三个模板函数如下： int addSet(T * myset, T e...
改造BeanUtils，优雅实现List数据拷贝
Wewe的博客
04-29 327
如果 source 或者 targetSupplier 只要有一个为 null，本工具类不像 BeanUtils 一样抛出异常，而是返回 null，因为笔者认为调用方如果把 null 进行准换，那就是想转换为 null，为不为空应该由调用方自己负责。. 这种拷贝方式是没有返回值的，jdk8 支持 stream() 操作之后，支持不是很友好，不方便 lambda 表达式的使用，因此我们决定通过集成 BeanUtils 类，自己造一个方便用的轮子。可还是有一些不够完美的地方。
HarmonyOS开发案例：【使用List组件实现设置项】
m0_70748845的博客
04-27 996
在本篇CodeLab中，我们将使用List组件、Toggle组件以及Router接口，实现一个简单的设置页，点击将跳转到对应的详细设置页面。
list
2301_80423154的博客
04-27 363
链表排序（所有不支持随机访问迭代器的容器，不可以用标准算法）可以对任意位置进行快速的插入和删除。遍历速度没有数组快，占用空间大。
C++中常见容器总结Array-Vector-List-Queue-Stack-Map-Set
book_dw5189的博客
04-28 419
在 C++ 中，有许多常见的容器，每种都有其特定的用途和性能特征。
Java基础_集合类_List
qq_44600808的博客
04-24 1192
Collection接口的骨架式实现类，最小化实现Collection接口的代价。List接口的骨架式实现类，最小化实现List接口的代价。**“随机访问”**数据存储。提供了iterator()、listIterator()方法的实现。重要属性修改次数，迭代器和列表迭代器使用】如果该字段的值发生意外变化，迭代器(或列表迭代器)将抛出，以响应操作。这提供了快速故障行为，而不是在迭代期间面对并发修改时的不确定性行为。List接口的框架实现，**“顺序访问”**数据存储。
net lambda 、 匿名函数 以及集合（实现IEnumerable的 如数组 、list等）
最新发布
u013400314的博客
04-30 160
FirstOrDefault : 获取第一个，如果一个都没有则返回默认值（如果是值类型，默认值0 如果是引用类型 则默认值 null）如果委托有返回值，并且方法体只有一个行代码，且这行代码还是返回值， 则可以 省略 大括号 和 return。SingeOrDefault ： 获取唯一一个，如果没有则返回默认值，如果有多个，则抛出异常。Singe ： 获取唯一一个，如果没有或者有多个，则抛出异常。First ： 获取第一个，如果一个都没有，则抛出异常。
边循环边删除List中的数据
G_whang的博客
04-30 202
删除的所有，但是最终还留下两个值，这是因为当一个元素被移除时，该List的大小(size)就会缩减，同时也改变了索引的指向，也就是上面的代码只会循环两次，长度在不断减少，第一次循环0 < 4 ，第二次循环 1 < 3 ，不满足下一次循环条件 2 < 2，故只有两次循环就结束。这是因为，在 foreach循环中，编译器使得 remove()方法先于next()方法被调用，因为先执行了remove()方法，导致next()获取的数组长度和remove()后的数组长度不一致，则抛出异常。List边循环，边删除；
c++模拟实现vector
09-01
总结来说，c语言模拟实现vector的关键是动态内存管理和对元素的增删改查操作。可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值