LIST增删查改的模拟实现

于 2024-06-03 19:27:42 发布
阅读量232 收藏 1
点赞数 4
文章标签： windows microsoft 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alanzeeb/article/details/139422340
版权

前言：


list的底层结构为带头结点的双向循环链表

大体框架：

namespace simulation {
	template <class T>

	struct list_node {
	//成员函数
	};

template<class T,class Ref,class Ptr>

	struct _list_iterator {
	//成员函数
	};

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;
	//成员函数
		private:
		Node* _head;
		size_t _size;
	};
	}



一、节点的封装（list_node）

template <class T>
	struct list_node {
		//带头的双向循环链表

		//在类模板中：

		//类名不等于类型，所以定义指针时类名要显示实例化

		list_node<T>* _prev;
		list_node<T>* _next;
		T _val;

		list_node(const T&val=T())

			//T（）相当于调用构造函数；
			:_prev(nullptr)
			,_next(nullptr)
			,_val(val)
		{}
	};


二、迭代器的封装(_list_iterator)


因为list的数据不是在一片连续的内存中（像vector，string那样），所以我们不能用原生指针来当迭代器iterator，我们要自己设计一个迭代器，自己去实现其++以及比较等操作。

1.类模板的定义：
//设计const迭代器：可以把迭代器理解为类似指针

	// 错误示范： typedef const __list_iterator<T> const_iterator;
	// 这样设计const迭代器是不行的，因为const迭代器期望指向内容不能修改
	// 这样设计是迭代器本身不能修改
	 
	//为了设计不那么繁琐，我们传入三个模板参数
	template<class T,class Ref,class Ptr>

	//相当于：
	// typedef __list_iterator<T, T&, T*> iterator;
		// typedef __list_iterator<T, const T&, const T*> const_iterator;

2.构造函数
typedef list_node<T> Node;
		typedef _list_iterator<T, Ref, Ptr> self;
		Node* _node;//成员变量

		_list_iterator(Node* node)
			:_node(node)
		{}

3.前置++，后置++
self& operator++() {//前置++

		//typedef _list_iterator<T, Ref, Ptr> self;
			_node = _node->_next;
			return *this;
		}

		self operator++(int) {
//后置++
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}

4.前置–，后置–
self& operator--() {
			_node = _node->_prev;
			return *this;
		}

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


5.解引用(operator*())
Ref operator*() {
		//因为可能为const T&类型或者T&类型
		//为了避免繁琐，使用模板参数里面的Ref
		//编译器根据不同的类型会生成对应的函数

			return _node->_val;
		}

6. ->重载（operator- >()）
 
    //template<class T,class Ref,class Ptr>

	//相当于：
	// typedef __list_iterator<T, T&, T*> iterator;

	// typedef __list_iterator<T, const T&, const T*> const_iterator;
Ptr operator->() {
			return&_node->_val;
		}

7.比较运算符的重载：
       bool operator!=(const self& it)const {
			return _node != it._node;
		}

		bool operator==(const self& it)const {
			return _node == it._node;
		}


三、list成员函数


1.构造函数
typedef list_node<T> Node;
	public:
		typedef _list_iterator<T, T&, T*> iterator;
		typedef _list_iterator<T, const T&, const T*>  const_iterator;
		void empty_init() {
			_size = 0;
			_head = new Node;
			_head->_prev = _head;
			_head->_next = _head;
		}

		list() {//构造函数
			empty_init();
		}

   private：
         Node*_head;//哨兵位
         size_t _size;

2.begin(),end()
         iterator begin() {
         //begin（）为哨兵位下一个
			return _head->_next;
		}

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

		//end（）为哨兵位
		iterator end() {
			return _head;
		}

		const_iterator end()const {
			return _head;
		}

3.插入（insert）在pos之前一个位置插入


在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

iterator insert(iterator pos, const T& x) {
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* newnode = new Node(x);
			newnode->_prev = prev;
			newnode->_next = cur;
			prev->_next = newnode;
			cur->_prev = newnode;
			++_size;

			//返回指向第一个新插入元素的迭代器。
			return newnode;
		}


4.删除（erase）
iterator erase(iterator pos) {
			assert(pos != end());
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			prev->_next = next;
			next->_prev = prev;
			--_size;

			//返回被删除节点的下一个位置
			return next;
		}

5.尾插尾删
	void push_front(const T& x) {
			insert(begin(), x);
		}

		void pop_back() {
			erase(--end());
		}

6.头插头删
void push_back(const T&x) {
			insert(end(), x);
		}

void pop_front() {
			erase(begin());
		}

7.析构函数
        void clear() {
			 
			iterator it = begin();
			while (it != end()) {
				it = erase(it);
			}
			_size = 0;
		}

		~list() {
			clear();
			delete _head;
			_head = nullptr;
		}


8.赋值运算符重载
void swap(list<T>&lt){
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		list<T>operator=(list<T> lt) {
			swap(lt);
			return *this;
		}


9.拷贝构造函数
   
     list(const list<T>& lt) {
			empty_init();
			_size = lt._size;

			for (auto &ch : lt) {
				push_back(ch);
			}
			
		}


10.大小（size）
size_t size() {
			return _size;
		}

四，完整代码

#pragma once
#include<iostream>
using namespace std;
namespace bit
{
	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;
		list_node(const T& x=T())
			:_data(x)
			,_next(nullptr)
			,_prev(nullptr)
		{}
	};
	//T T& T*
	//T const T& const T*
	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)
		{}
		self& operator++()
		{
			_node = _node->_next;
			return *this;
		}
		self& operator--()
		{
			_node = _node->_prev;
			return *this;
		}
		self operator++(int) //能用前置就不要用后置，后置要返回++之后的
		{
			self tmp(*this);
			_node = _node->_next;
			return tmp;
		}
		self operator--(int) 
		{
			self tmp(*this);
			_node = _node->_prev;
			return tmp;
		}
		Ref operator*()
		{
			return _node->_data;
		}
		Ptr operator->()
		{
			return &_node->_data;
		}
		bool operator!=(const self& s)
		{
			return _node != s._node;  //看节点的指针是否相等
		}
		bool operator==(const self& s)
		{
			return _node == s._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;//通过模板参数去控制是普通迭代器还是const
		const_iterator begin() const
		{
			return const_iterator(_head->_next);
			//也可以写成 return _head->_next;隐式类型转换，和上面是一样的
		}
		const_iterator end() const//哨兵卫位置
		{
			return const_iterator(_head);
		}
		iterator begin()
		{
			return iterator(_head->_next);
		}
		iterator end() //哨兵卫位置
		{
			return iterator(_head);
		}
		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
		list()
		{
			empty_init();
		}
		//lt2(lt1)   lt2拷贝构造lt1,this就是lt2
		list(const list<T>& lt)
		{
			empty_init();
			for (auto e : lt)
			{
				push_back(e); 
			}
		}
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);//交换头指针
			std::swap(_size, lt._size);//交换_size
		}
		//lt3=lt1  lt就是lt1的拷贝构造  赋值重载
		list<int>& operator=(const list<int>& lt)
		{
			//现代写法
			swap(lt);
			return *this;
		}
		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		void clear()
		{
			//清理数据,不清头节点
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);//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_front()//头删就是在begin位置删除
		{
			erase(begin());
		}
		void pop_back()//尾删
		{
			erase(--end());
		}
		iterator insert(iterator pos, const T& x)//在pos之前插入x
		{
			Node* cur = pos._node;
			Node* newnode = new Node(x);
			Node* prev = cur->_prev;
			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			++_size;
			return iterator(newnode);
		}
		iterator erase(iterator pos) //在pos位置删除
		{
			Node* cur = pos._node;
			Node* prev = cur->_prev;
			Node* next = cur->_next;
			delete cur;
			prev->_next = next;
			next->_next = prev;
			--_size;
			return iterator(next);
		}
		size_t size()
		{
			return _size;
		}
	private:
		Node* _head;
		size_t _size;
	};
	void test_list1()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_back(5);
		//封装屏蔽底层差异和实现细节
		//提供统一的访问修改遍历方式
		list<int>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
	struct AA
	{
		AA(int a1=0,int a2=0)
			:_a1(a1)
			,_a2(a2)
		{}
		int _a1;
		int _a2;
	};
	void test_list2()
	{
		list<AA> lt; //list中存的是自定义类型
		lt.push_back(AA(1, 1));
		lt.push_back(AA(2, 2));
		lt.push_back(AA(1, 3));
		list<AA>::iterator it = lt.begin();
		while (it != lt.end())
		{
		//	cout << *it << " ";//*it是A,A不支持流插入
		//	cout << (*it)._a1 << " " << (*it)._a2<<endl;
			cout << it->_a1 << " " << it->_a2 << endl;
			++it;
		}
		cout << endl;
	}
	void print_list(const list<int>&lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			//*it = 10;不能修改，调用operator*返回data的别名，加const不能修改
			cout << *it << " ";
			it++;
		}
	}
	void test_list3()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		lt.push_back(5);
		print_list(lt);
	}
}

Alanzeeb
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C++】STL——list（部分功能模拟实现、迭代器、反向迭代器）
小胡同学的博客
05-23 256
STL中的list底层实现是用带头循环的双链表，这种结构设计巧妙的使得list能够在随机位置插入删除的效率搞，但处理不了大量数据，相比于vector，vector的随机位置删除的速度就低于list ，因为vector需要挪动数据，而list直接把链子相接就可以了那么list在使用的时候不难，stl的容器相似性很强，所以这次list的实现能更让我们学会c++关于封装的理解，c++类和对象的巩固，通过各种模板的类型，迭代器的封装，反向迭代器的封装使用。
MyEclipse下用Mybatis框架搭建工程并实现条件的增删查改及结果映射
gaofengyan的博客
10-13 2092
代码中关于说明都有详细注解，不再一一赘述。 database.properties配置文件： driver=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/smbms username=root password=123456 log4j.properties日志配置文件： log4j.rootLogger=DEBUG,CONSOLE,...
【C++】STL中list的模拟实现（增删查改，迭代器封装，运算符重载）
m0_74774759的博客
07-27 762
list的底层结构为带头结点的双向循环链表//设计const迭代器：可以把迭代器理解为类似指针 // 错误示范： typedef const __list_iterator const_iterator;
C++——list的增删查改的模拟实现
清风彬的博客
11-22 669
#include <iostream> namespace bite { // List的节点类 template<class T> struct ListNode { ListNode(const T& val = T()); ListNode<T>* _pPre; ListNode<T>* _pNext; T _val; }; //List的迭代器类 template<class T, class Ref, cl
C++:list增删查改模拟实现
最新发布
Zhenyu_Coder的博客
12-25 4842
一、list底层双链表验证、节点构造 二、迭代器封装实现（重点、难点） 2.2 迭代器实现 三、list实现 3.1 基本框架3.2 迭代器和const迭代器3.2 构造函数、析构函数、拷贝构造、赋值重载3.3 任意位置插入、任意位置删除、尾插、尾删、头插、头删 四、list功能完善4.1 迭代器operator->()4.2 打印数据 五·、所有代码以及测试用例
list的模拟实现
qq_41490958的博客
10-26 694
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
DataGridView实现增删查改
11-17
在本教程中，我们将深入探讨如何利用`DataGridView`控件实现数据的增删查改功能，以创建一个简单的数据库应用，例如模拟一个"i商城购物"系统。 首先，我们需要一个数据源来存储和管理数据。在提供的文件中，`i商城...
使用android进行数据库增删查改及实现get post
miaowuuuuu的博客
06-29 368
/无参构造 public Student() {} //有参构造 public Student(String name , String number , String gender , Integer score) {} }
python怎样用数组的方式操作myswl增删查改
05-30
在Python中，我们可以使用MySQL官方提供的Python数据库API模块`mysql-connector-python`来连接MySQL数据库，然后使用列表(list)来模拟数组的方式操作MySQL数据库实现增删查改。 下面是一个简单的示例代码，实现了...
JAVA集合-LIst集合实现商品的CRUD(增删改查)
weixin_43515260的博客
07-13 532
JAVA集合-LIst集合实现商品的CRUD(增删改查)
重写C++的list实现增 删 改的功能
09-23
类模板，list，C++，重写增，删，改功能。 重写C++的list,实现增，删，改的功能 是一个学习类模板的不错的例子
【C++】list的使用 | 模拟实现
大三小白C++进阶之路
03-17 1088
list容器的基本使用和模拟实现
【C++: list的模拟实现】
m0_68872612的博客
02-08 2125
通俗易懂的讲解C++STL中list底层实现，干货满满快来看看吧！
c++ list 修改_一线码农java系列之List
weixin_35133280的博客
12-26 441
List概述List属于Java集合系统一员。List本身是一个interface继承了Collection接口。List中定义各种对集合的操作，List的具体实现包括ArrayList、Vector和LinkedList等，List所处位置如下图所示(非完整图): List提供了特殊迭代器ListIterator，该迭代器提供了双向迭代访问集合的功能。 接口方法如下所示: Lis...
【万字总结】C++——list的基本使用和模拟实现(建议收藏)
m0_57249790的博客
11-01 1895
1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高 效。4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率 更好。
C++迭代器
weixin_67051070的博客
05-08 497
要使用迭代器，需要包含头文件，并使用容器类名后面加上::iterator或::const_iterator来定义迭代器变量。
【C++】list 迭代器详解和模拟实现
睡不醒的猫的博客
05-04 1492
通过对比我们可以看到，list sort 的效率要远低于 vector sort，甚至可以说，使用list sort 还不如把 list 的数据拷贝到vector中进行排序，然后使用vector sort排序后，再将数据拷贝到 list 中快。这里对 list 和 vector 分别在vs和Linux的编译器下插入相同的元素进行排序对比，通过比较来深刻了解这两种容器在排序性能上的差别，可以帮助我们更直观地感受两种容器的区别，以便更好的使用它们。1. vector排序和 list 排序对比。
c++ stl list 迭代器简单实现
人不一定要生得漂亮，但一定要活得漂亮！
07-16 3932
#includetemplateclass node{    public:        T data;        void * pre;        void * next;};templateclass iter{    public:        typedef node * lnode;        lnode pnode;        iter(iter& a):pnode
C++ list类（包括反向迭代器适配器的实现）
冰果滴的博客
07-18 2779
前言list类的学习，可以仿照之前的string类和vector类。（这里的反向迭代器是一个适配器，适配正向迭代器）
java中list增删查改
03-27
List是Java中常用的集合类型之一，常用的增删查改操作如下： 1. 增加元素： 可以使用add()方法将元素添加到List中，如： ``` List<String> list = new ArrayList(); list.add("apple"); list.add("banana"); list...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值