List ---- 模拟实现LIST功能的发现

目录

  • list
    • list概念
  • list 中的迭代器
    • list迭代器知识
    • const迭代器写法
    • list访问自定义类型
  • 附录代码

list

list概念

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向
    其前一个元素和后一个元素。
  3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高
    效。
  4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率
    更好。
  5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list
    的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间
    开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这
    可能是一个重要的因素)

在这里插入图片描述

list 中的迭代器

有兴趣的可以直接跳转附录代码中，里面几乎涵盖了所有的问题答案

list迭代器知识

迭代器原理就是对原生指针的封装，帮助我们更好的使用指针来对节点的内容进行访问。

迭代器目前学习的进度来看是分成普通迭代器和const迭代器。在对list的模拟实现过程中发现了许多新的迭代器知识点。

const迭代器写法

由于对迭代器封装后的代码重命名为：typedef __list_iterator<T > iterator;
所以下意识会认为const迭代器应该是这个样子的：//typedef __list_const_iterator<T> const_iterator;
实际上这是有问题的！

因为const迭代器修饰的应该节点内部的数据不可以被修改，而迭代器本身是可以前后移动来遍历链表。 而 const_iterator所表达的意思是T* const，但是我们想要的是const T*。 这两者的区别便是前一个T* const可以修改节点内部数据信息，但因为不可以修改地址所以不能遍历链表，，而后一个const T*不可以修改数据信息，但是可以遍历链表。
要想办法实现const T*！！！！

list中的const迭代器实际上是保证对信息不可修改，所以只需要对读取信息的操作赋予控制是否为const属性的操作，即为T* operator*()确保在某些时刻是const属性。所以可以在模板上对其进行特殊化操作： template<class T, class Ref>

	template<class T, class Ref>
	struct __list_iterator
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref> self;
		node* _node;
		__list_iterator(node* n)
			:_node(n)
		{}

		Ref operator*()//T* operator()
		{
			return _node->_data;
		}
	};
	template<class T>
	class list
	{
		typedef list_node<T> node;
	public:
		typedef __list_iterator<T, T&> iterator;//使用普通迭代器就更改Ref就好了
		typedef __list_iterator<T, const T&> const_iterator;

在需要const迭代器时候，传递const T&，而需要普通迭代器就直接传递T&,这样不仅解决的繁琐的复用问题，还能够满足使用。

list访问自定义类型

迭代器要么是原生指针，要么是自定义类型对原生指针的封装，在模拟指针的行为。

而访问自定义类型不能使用解引用操作，而是使用访问操作符->,所以list库对访问自定义类型也做了对应的设置，即重载operator->

但是因为要访问自定义类型就一棒子大打死，就只能使用operator->来进行访问，内部的函数大可以直接访问，而复用又太过于繁琐了，所以又新增了特殊的模板类，控制是访问自定义类型还是访问内部函数！

	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* n)
			:_node(n)
		{}
		Ptr operator->()
		{
			return &_node->_data;
		}
		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;
	}

	struct AA
	{
		int _a1;
		int _a2;

		AA(int a1 = 0, int a2 = 0)//全缺省的默认构造
			:_a1(a1)
			, _a2(a2)
		{}
	};

	void test_list2()
	{
		list<AA> lt;
		lt.push_back(AA(1, 1));
		lt.push_back(AA(2, 2));
		lt.push_back(AA(3, 3));
		list<AA>::iterator it = lt.begin();
		while (it != lt.end())
		{
			cout << it->_a1 << "," << it->_a2 << " ";
			++it;
		}
		cout << endl;
	}

因此不仅仅可以访问是否为const属性的信息，还可以控制访问是否为自定义类型的参数

附录代码

#pragma once

#include<iostream>
#include<assert.h>
using namespace std;
namespace lby
{
	template<class T>
	struct list_node //节点的类//struct默认为公有，不打算对内容进行限制就用struct
	{
		list_node<T>* _next;
		list_node<T>* _prev;
		T _data;

		list_node(const T& x = T())
			:_next(nullptr)
			, _prev(nullptr)
			, _data(x)
		{}
	};


	//迭代器要么是原生指针，要么是自定义类型对原生指针的封装，在模拟指针的行为

	template<class T, class Ref, class Ptr>//使用普通迭代器就更改Ref就好了
	struct __list_iterator//封装的是迭代器，而迭代器的本质是用一个类去封装这个 node*,即指针指向这个链表的头节点
	{
		typedef list_node<T> node;
		typedef __list_iterator<T, Ref, Ptr> self;
		node* _node;//注意节点的指针不属于迭代器，只是让迭代器封装之后的一系列操作，不支持释放，释放是链表的事情，迭代器只能使用节点，不能释放节点

		__list_iterator(node* n)
			:_node(n)
		{}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}
		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& x)//传递的是迭代器中的x
		{
			return _node != x._node;
		}
		bool operator==(const self& x)
		{
			return _node == x._node;
		}
	};

	/*template<class T>
	struct __list_const_iterator//封装的是迭代器，而迭代器的本质是用一个类去封装这个 node*,即指针指向这个链表的头节点
	{
		typedef list_node<T> node;
		typedef __list_const_iterator<T> self;
		node* _node;//注意节点的指针不属于迭代器，只是让迭代器封装之后的一系列操作，不支持释放，释放是链表的事情，迭代器只能使用节点，不能释放节点

		__list_const_iterator(node* n)
			:_node(n)
		{}

		const T& operator*()//控制整个返回值不可修改
		{
			return _node->_data;
		}

		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& x)//传递的是迭代器中的x
		{
			return _node != x._node;
		}
		bool operator==(const self& x)
		{
			return _node == x._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;
		//typedef __list_const_iterator<T>  const_iterator;

		//typedef const iterator const_itrator;//绝对不可以，这种方式const修饰的是地址 --> T* const，而不是const T*；


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

		//iterator begin() const//这里有个问题，既然是const指针，那就应该是常量，但是为什么你还能改变指向的位置？
		//{
		//	return iterator(_head->_next);//因为const指针修饰的是*this，即this指针指向的内容，它指向的内容是_head这个的指针，
		//								  //即为修饰的是_head这个指针本身！也就是说_head本身不能被改变，它指向的内容是可以改变的
		//								  //但是与我们的预期不符，因为const迭代器他是只读操作，不允许改变内容，如果他内容是可以改变的，我为什么要使用const迭代器呢
		const迭代器与普通迭代器区别是：const迭代器本身是可以修改的(可以前后移动去访问)，但是const迭代器指向的内容是不可以修改的--> 要const T*，不要T* const ！
		//}
		//iterator end() const
		//{
		//	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;
		}

		list()
		{
			empty_init();
		}

		template<class Iterator>
		list(Iterator first, Iterator last)
		{
			empty_init();//先构造头节点

			while (first != last)
			{
				push_back(*first);//push_back 的前提是有哨兵位的头节点，所以需要先构造头节点
				++first;
			}
		}

		void swap(list<T>& t)
		{
			std::swap(_head, t._head);
		}

		list(const list<T>& lt)//lt2(lt1)
		{
			/*empty_init();//正常写法
			for (auto e : lt)
			{
				push_back(e);
			}*/
			empty_init();
			list<T> tmp(lt.begin(), lt.end());//借助模板类进行复制后交换
			swap(tmp);
		}

		//lt1 = lt3	
		list<T>& operator=(list<T> lt)//(list<T>& lt)不能引用传引用，因为会将原来的lt进行修改
		{
			swap(lt);
			return *this;
		}

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}
		
		void clear()
		{
			iterator it = begin();
			while (it != end())
			{
				it = erase(it);
				//erase(it++);//这个地方析构的值是返回的迭代器对象，是it的拷贝，不是it
			}
		}

		void push_back(const T& x)
		{
			//node* tail = _head->_prev;
			//node* new_node = new node(x);//需要node(list_node<T>)的构造函数

			//tail->_next = new_node;
			//new_node->_prev = tail;
			//new_node->_next = _head;
			//_head->_prev = new_node;

			insert(end(), x);
		}

		void push_front(const T& x)
		{
			insert(begin(), x);
		}

		void insert(iterator pos, const T& x)//链表的迭代器插入数据不会失效，因为pos指针指向的位置是不变的
		{
			node* cur = pos._node;
			node* prev = cur->_prev;

			node* new_node = new node(x);

			prev->_next = new_node;
			new_node->_prev = prev;
			new_node->_next = cur;
			cur->_prev = new_node;
		}

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

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

		iterator erase(iterator pos)//由于pos指针位置被析构了，所以迭代器失效了
		{
			assert(pos != end());

			node* prev = pos._node->_prev;
			node* next = pos._node->_next;

			prev->_next = next;
			next->_prev = prev;
			delete pos._node;

			return iterator(next);
		}

	private:
		node* _head;
	};

	void print_list(const list<int>& lt)
	{
		list<int>::const_iterator it = lt.begin();
		while (it != lt.end())
		{
			//(*it) *= 2;//const不可修改
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}


	void test_list1()
	{
		const list<int> l;//const对象在定义时，最开始不会赋给常值，因为要初始化，否则没办法进行初始化，之后才会赋给const属性
						 //const对象在定义的一瞬间不会给const属性

		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())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		print_list(lt);
	}

	struct AA
	{
		int _a1;
		int _a2;

		AA(int a1 = 0, int a2 = 0)//全缺省的默认构造
			:_a1(a1)
			, _a2(a2)
		{}
	};

	void test_list2()
	{
		list<AA> lt;
		lt.push_back(AA(1, 1));
		lt.push_back(AA(2, 2));
		lt.push_back(AA(3, 3));

		list<AA>::iterator it = lt.begin();
		while (it != lt.end())
		{
			//cout << (*it)._a1 << " " << (*it)._a2 << " ";
			cout << it->_a1 << "," << it->_a2 << " ";//由于函数重载了 -> ，所以本来应该是it->->_a1,编译器优化了设置，变成了it->_a1;
													 //it.operator->()->_a1,it.operator->()返回的是T*，T*->_a1就可以访问
			++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);

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		auto pos = lt.begin();
		++pos;
		lt.insert(pos, 100);

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.push_front(200);
		lt.push_front(300);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.push_back(400);
		lt.push_back(500);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.pop_back();
		lt.pop_front();
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		lt.pop_back();
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;
	}


	void test_list4()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		lt.clear();
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;
		lt.push_back(10);
		lt.push_back(2);
		lt.push_back(30);
		lt.push_back(1);
		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;
	}

	void test_list5()
	{
		list<int> lt;
		lt.push_back(1);
		lt.push_back(2);
		lt.push_back(3);
		lt.push_back(4);

		for (auto p : lt)
		{
			cout << p << " ";
		}
		cout << endl;

		list<int> lt2(lt);
		for (auto e : lt2)
		{
			cout << e << " ";
		}
		cout << endl;
	}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/949617.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Matlab回归预测大合集(不定期更新)-188

Matlab回归预测大合集(不定期更新)-188

截至2025-1-2更新 1.BP神经网络多元回归预测&#xff08;多输入单输出&#xff09; 2.RBF神经网络多元回归预测&#xff08;多输入单输出&#xff09; 3.RF随机森林多元回归预测&#xff08;多输入单输出&#xff09; 4.CNN卷积神经网络多元回归预测&#xff08;多输入单输…
阅读更多...
go语言zero框架中教务crm系统的在职继承和离职交接的设计与实践

go语言zero框架中教务crm系统的在职继承和离职交接的设计与实践

在GoZero中实现一个在职继承和离职交接的通用模块&#xff0c;涉及到顾问离职交接客户、领导离职交接审批单据等功能。为了使这个模块通用且易于扩展&#xff0c;我们可以分成几个部分&#xff1a; 1. **数据模型设计**&#xff1a;我们首先需要设计离职交接相关的数据模型。 …
阅读更多...
Mac软件介绍之录屏软件Filmage Screen

Mac软件介绍之录屏软件Filmage Screen

软件介绍 Filmage Screen 是一款专业的视频录制和编辑软件&#xff0c;适用于 Mac 系统 可以选择4k 60fps&#xff0c;可以选择录制电脑屏幕&#xff0c;摄像头录制&#xff0c;可以选择区域录制。同时也支持&#xff0c;简单的视频剪辑。 可以同时录制电脑麦克风声音 标准…
阅读更多...
毕业项目推荐：基于yolov8/yolov5的行人检测识别系统（python+卷积神经网络）

毕业项目推荐：基于yolov8/yolov5的行人检测识别系统（python+卷积神经网络）

文章目录 概要一、整体资源介绍技术要点功能展示&#xff1a;功能1 支持单张图片识别功能2 支持遍历文件夹识别功能3 支持识别视频文件功能4 支持摄像头识别功能5 支持结果文件导出&#xff08;xls格式&#xff09;功能6 支持切换检测到的目标查看 二、数据集三、算法介绍1. YO…
阅读更多...
对话｜企业如何构建更完善的容器供应链安全防护体系

对话｜企业如何构建更完善的容器供应链安全防护体系

对话&#xff5c;企业如何构建更完善的容器供应链安全防护体系 云布道师 随着云计算和 DevOps 的兴起&#xff0c;容器技术和自动化成为软件开发中的必要手段&#xff0c;软件供应链也进入了自动化及 CI/CD 阶段。然而&#xff0c;容器技术和自动化虽然提升了软件的更新速度&…
阅读更多...
小试牛刀-SpringBoot集成SOL链

小试牛刀-SpringBoot集成SOL链

目录 一、什么是solanaj? 二、Pom依赖 三、主要类 3.1 RpcClient 3.2 PublicKey 3.3 Transaction 3.4 TransactionInstruction 四、示例代码 Welcome to Code Blocks blog 本篇文章主要介绍了 [小试牛刀-SpringBoot集成SOL链] ❤博主广交技术好友&#xff0c;喜欢文章的…
阅读更多...
LLM之RAG实战（五十一）| 使用python和Cypher解析PDF数据，并加载到Neo4j数据库

LLM之RAG实战（五十一）| 使用python和Cypher解析PDF数据，并加载到Neo4j数据库

一、必备条件&#xff1a; python语言Neo4j数据库python库&#xff1a;neo4j、llmsherpa、glob、dotenv 二、代码&#xff1a; from llmsherpa.readers import LayoutPDFReaderfrom neo4j import GraphDatabaseimport uuidimport hashlibimport osimport globfrom datetime …
阅读更多...
牛客网刷题 ——C语言初阶(5操作符)——BC117 小乐乐走台阶

牛客网刷题 ——C语言初阶(5操作符)——BC117 小乐乐走台阶

1.题目 &#xff1a;BC117 小乐乐走台阶 牛客OJ题链接 描述 小乐乐上课需要走n阶台阶&#xff0c;因为他腿比较长&#xff0c;所以每次可以选择走一阶或者走两阶&#xff0c;那么他一共有多少种走法&#xff1f; 输入描述&#xff1a; 输入包含一个整数n (1 ≤ n ≤ 30) …
阅读更多...
gitlab高级功能之 CICD Steps

gitlab高级功能之 CICD Steps

CICD Steps 1. 介绍2. 定义 Steps2.1 Inputs2.2 Outputs 3. Using steps3.1 Set environment variables3.2 Running steps locally 4. Scripts5. Actions5.1 已知的问题 6. 表达式7. 实操7.1 单个step7.2 多个step7.3 复用steps7.4 添加output到step7.5 使用远程step 1. 介绍 …
阅读更多...
【Unity3D】UGUI Canvas画布渲染流程

【Unity3D】UGUI Canvas画布渲染流程

目录 Screen Space - Overlay Screen Space - Camera World Space UI合批分析&#xff08;建议不看 直接看FrameDebugger测试&#xff09; 优化UI合批 1、Image图片纹理不同导致合批失败 2、文本和图片相交以及排序对合批的影响 3、Mask对合批的影响&#xff08;情况…
阅读更多...
平安产险安徽分公司携手安徽中医药临床研究中心附属医院 共筑儿童安全防护网

平安产险安徽分公司携手安徽中医药临床研究中心附属医院 共筑儿童安全防护网

为响应金融知识普及教育号召&#xff0c;平安产险安徽分公司联动安徽中医药临床研究中心附属医院&#xff0c;于近日在朝霞小学举办了一场儿童安全防范与健康守护活动。此次活动旨在提升学生的安全防范意识&#xff0c;守护儿童健康成长&#xff0c;同时有力推动金融知识与传统…
阅读更多...
zephyr移植到STM32

zephyr移植到STM32

Zephy如何移植到单片机 1. Window下搭建开发环境1.1 安装Choncolatey1.2 安装相关依赖1.3创建虚拟python环境1.4 安装west1.4.1 使用 pip 安装 west1.4.2 检查 west 安装路径1.4.3 将 Scripts路径添加到环境变量1.4.4 验证安装 1.5 获取zephyr源码和[安装python](https://so.cs…
阅读更多...
fail api scope is not declared in the privacy agreement微信小程序uniapp 解决录音无法播放、授权

fail api scope is not declared in the privacy agreement微信小程序uniapp 解决录音无法播放、授权

已解决 fail api scope is not declared in the privacy agreement微信小程序uniapp 解决录音无法播放、授权 没有声明内容协议导致的 微信公众平台&#xff1a;https://mp.weixin.qq.com/【1.左下角的-移动过去后会出现 “帐号设置”】 【2.基本设置->服务内容声明->修…
阅读更多...
虚拟机 网络防御(预防信息泄露)

虚拟机 网络防御(预防信息泄露)

了解VMware网络基本配置 Bridged(桥接模式):虚拟机和主机好比在同一个网络环境下的两台电脑。 NAT(网络地址转换模式):NAT模式虚拟机通过主机进行联网。&#xff08;推荐&#xff09; Host-0nly(主机模式):主机模式将虚拟机与外网隔开&#xff0c;只能让虚拟机和虚拟机之间联…
阅读更多...
打包部署若依(RuoYi)SpringBoot后端和Vue前端图文教程

打包部署若依(RuoYi)SpringBoot后端和Vue前端图文教程

打包后端‘ 1&#xff0c;打开若依&#xff0c;点击右侧的Maven展开Maven管理&#xff0c;选择ruoyi>Lifecycle 先双击clean清除原本启动项目时生成的文件。然后点击package等待项目打包&#xff0c;切记要取消运行再打包 打包完成后会在ruoyi-admin>src>target里面…
阅读更多...
矩阵碰一碰发视频源码搭建全解析，支持OEM

矩阵碰一碰发视频源码搭建全解析，支持OEM

在数字化营销与互动体验需求日益增长的当下&#xff0c;矩阵碰一碰发视频功能以其独特的交互性和高效的信息传播能力&#xff0c;正逐渐成为吸引用户、提升品牌影响力的有力工具。本文将深入探讨如何搭建矩阵碰一碰发视频的源码&#xff0c;帮助开发者实现这一创新功能。 一、技…
阅读更多...
专题十四——BFS

专题十四——BFS

目录 一BFS解决FloodFill算法 1图像渲染 2岛屿数量 3岛屿的最大面积 4被环绕的区域 二BFS解决蛋源最短路径问题 1迷宫中离入口最近的出口 2最小基因变化 3单词接龙 4为高尔夫比赛砍树 三BFS解决多源最短路径问题 1 01矩阵 2飞地的数量 3地图中的最高点 4地图分…
阅读更多...
openwrt 清缓存命令行

openwrt 清缓存命令行

一、查看缓存 &#xff1a; free -m 二、清缓存&#xff1a;echo 3 > /proc/sys/vm/drop_caches　 三、详解。 释放物理页缓存 echo 1 > /proc/sys/vm/drop_caches 释放可回收的slab对象&#xff0c;包含inode and dentry echo 2 > /proc/sys/vm/drop_caches 同时…
阅读更多...
huggingface 下载方法 测试ok

huggingface 下载方法 测试ok

目录 python下载方法&#xff1a; 设置环境变量 ~/.bashrc 缓存目录&#xff0c;默认模型下载目录 安装方法&#xff1a; python 下载无token&#xff1a; python 下载带token 常见报错 登录后创建Read token 2.3 创建token 使用token登录 python下载方法&#xff1…
阅读更多...
滑动窗口_⻓度最⼩的⼦数组⽆重复字符的最⻓⼦串将x减到0的最⼩操作数

滑动窗口_⻓度最⼩的⼦数组⽆重复字符的最⻓⼦串将x减到0的最⼩操作数

⻓度最⼩的⼦数组&#xff08;medium https://leetcode.cn/problems/minimum-size-subarray-sum/ 思路一&#xff1a;两个指针&#xff0c;p1 p2同时指向第一个元素。sump2,如果sum<target&#xff0c;p2直到大于&#xff0c;然后记录lenright-left。p1 p2再同时指向第二个…
阅读更多...
最新文章

Copyright @ 2022~2023