[STL-list]介绍、与vector的对比、模拟实现的迭代器问题

一、list使用介绍

  1.  list的底层是带头双向链表结构,双向链表中每个元素存储在互不相关的独立节点中,在节点中通过指针指向其前一个元素和后一个元素。
  2. 与其他的序列式容器相比(array,vector,deque),list通常在任意位置进行插入、移除元素的执行效率更好
  3. list最大的缺陷是不支持任意位置的随机访问,比如:要访问list的第6个元素,必须从已知的位置(比如头部或者尾部)迭代到该位置,在这段位置上迭代需要线性的时间开销;
常用接口:

构造函数:

构造函数接口说明
list (size_type n, const value_type& val = value_type())构造的list中包含n个值为val的元素
list()构造空的list
list (const list& x)拷贝构造函数
list (InputIterator first, InputIterator last)用[first, last)区间中的元素构造list

代码演示:

    list<int> l1;                         // 构造空的l1
    list<int> l2(4, 100);                 // l2中放4个值为100的元素
    list<int> l3(l2.begin(), l2.end());  // 用l2的[begin(), end())左闭右开的区间构造l3
    list<int> l4(l3);                    // 用l3拷贝构造l4

    // 以数组为迭代器区间构造l5
    int array[] = { 16,2,77,29 };
    list<int> l5(array, array + sizeof(array) / sizeof(int));

    // 列表格式初始化C++11
    list<int> l6{ 1,2,3,4,5 };

list iterator的使用

对于迭代器的使用我们可以把它理解为一个指针,指向ist的某个节点

函数声明接口说明
begin + end返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
rbegin+ rend返回第一个元素的reverse_iterator,即end位置,返回最后一个元素下一个位置reverse_iterator,即begin位置

【注意】
1. begin与end为正向迭代器,对迭代器执行++操作,迭代器向后移动
2. rbegin(end)与rend(begin)为反向迭代器,对迭代器执行++操作,迭代器向前移动

代码演示:

    list<int> lt(4, 100);  
    list<int>::iterator it = lt.begin();
    while (it != lt.end())
    {
        cout << *it << " ";
        ++it;
    }       
    cout << endl;

    // C++11范围for的方式遍历
    for (auto& e : lt)
        cout << e << " ";
     cout << endl;

list modifiers

函数声明接口说明
push_front在list首元素前插入值为val的元素
pop_front删除list中第一个元素
push_back在list尾部插入值为val的元素
pop_back删除list中最后一个元素
insert在list position 位置中插入值为val的元素
erase删除list position位置的元素
swap交换两个list中的元素
clear清空list中的有效元素

代码演示:

void TestList1()
{
    int array[] = { 1, 2, 3 };
    list<int> L(array, array + sizeof(array) / sizeof(array[0]));

    // 在list的尾部插入4,头部插入0
    L.push_back(4);
    L.push_front(0);

    // 删除list尾部节点和头部节点
    L.pop_back();
    L.pop_front();
}

// insert /erase 
void TestList2()
{
    int array1[] = { 1, 2, 3 };
    list<int> L(array1, array1 + sizeof(array1) / sizeof(array1[0]));

    // 获取链表中第二个节点
    auto pos = ++L.begin();
    cout << *pos << endl;

    // 在pos前插入值为4的元素
    L.insert(pos, 4);

    // 在pos前插入5个值为5的元素
    L.insert(pos, 5, 5);

    // 在pos前插入[v.begin(), v.end)区间中的元素
    vector<int> v{ 7, 8, 9 };
    L.insert(pos, v.begin(), v.end());

    // 删除pos位置上的元素
    L.erase(pos);

    // 删除list中[begin, end)区间中的元素,即删除list中的所有元素
    L.erase(L.begin(), L.end());
}

// resize/swap/clear
void TestList3()
{
    // 用数组来构造list
    int array1[] = { 1, 2, 3 };
    list<int> l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));

    // 交换l1和l2中的元素
    list<int> l2;
    l1.swap(l2);

    // 将l2中的元素清空
    l2.clear();
    cout << l2.size() << endl;
}

其他接口

二、与vector对比

vectorlist



动态顺序表,一段连续空间带头结点的双向循环链表


访
支持随机访问,访问某个元素效率O(1)不支持随机访问,访问某个元素效率O(N)




任意位置插入和删除效率低,需要搬移元素,时间复杂度为O(N),插入时有可能需要增容,增容:开辟新空间,拷贝元素,释放旧空间,导致效率更低任意位置插入和删除效率高,不需要搬移元素,时间复杂度为
O(1)




底层为连续空间,不容易造成内存碎片,空间利用率高,缓存利用率高底层节点动态开辟,小节点容易造成内存碎片,空间利用率低,缓存利用率低


原生态指针对原生态指针(节点指针)进行封装




在插入元素时,要给所有的迭代器重新赋值,因为插入
元素有可能会导致重新扩容,致使原来迭代器失效,删
除时,当前迭代器需要重新赋值否则会失效
插入元素不会导致迭代器失效,删除元素时,只会导致当前迭代器失效,其他迭代器不受影响
使


需要高效存储,支持随机访问,不关心插入删除效率大量插入和删除操作,不关心随机访问

vector与list排序效率对比:

void test_op1()
{
	srand(time(0));
	const int N = 1000000;

	list<int> lt1;
	list<int> lt2;

	vector<int> v;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand() + i;
		lt1.push_back(e);
		v.push_back(e);
	}

	int begin1 = clock();
	// 
	sort(v.begin(), v.end());
	int end1 = clock();

	int begin2 = clock();
	lt1.sort();
	int end2 = clock();

	printf("vector sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);
}

 

void test_op2()
{
	srand(time(0));
	const int N = 1000000;

	list<int> lt1;
	list<int> lt2;

	for (int i = 0; i < N; ++i)
	{
		auto e = rand();
		lt1.push_back(e);
		lt2.push_back(e);
	}

	int begin1 = clock();
	// vector

	vector<int> v(lt2.begin(), lt2.end());
	// 
	sort(v.begin(), v.end());

	// lt2
	lt2.assign(v.begin(), v.end());

	int end1 = clock();

	int begin2 = clock();
	lt1.sort();
	int end2 = clock();

	printf("list copy vector sort copy list sort:%d\n", end1 - begin1);
	printf("list sort:%d\n", end2 - begin2);
}

可见list的排序效率是非常低的,甚至将list的数据导入vector中排完序在导回来的效率都比直接在list中排序的效率快,这是因为list不支持下标随机访问,只能依靠迭代器迭代到指定位置访问,而排序过程中避免不了需要访问大量中间元素,所以list并不适合对数据进行排序

三、list迭代器问题

链表节点与链表结构

节点包含三部分:前驱指针、后驱指针、数据。list封装了头节点的指针,可以根据该指针对后续节点进行遍历

    template<class T>
	struct ListNode
	{
		ListNode* _next;
		ListNode* _prev;
		T _data;
        //节点的构造函数
		ListNode(const T& x = T())
			:_next(nullptr)
			,_prev(nullptr)
			,_data(x)
		{}
	};

    template<class T>
	class list
	{
        void Empty_Init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

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

	private:
		Node* _head;
		size_t _size;
	};
如何设定list迭代器

        在string与vector的模拟实现中,迭代器使用的都是原生指针T*,这是因为原生指针可以满足迭代器的要求,++可以指向下一个元素,解引用可以访问该元素,他们可以使用原生指针的根本原因是他们储存数据的结构都是连续的物理地址。

        在list中原生指针Node*不能满足我们的要求,因为list的节点都是依靠指针连接起来的,其物理地址并不是连续的,++指向的并不是下一个元素,而是指向了跳过了一个Node的大小的的地址,并且迭代器希望解引用直接可以访问节点中的数据,而*(Node*)却是一个节点类型,所以在list中使用原生指针并不符合迭代器的要求。

         所以我们可以自己新建一个类,作为迭代器的类型,在其中封装了头节点,就可以访问该链表了,并且我们在该类中可以通过运算符重载改变++与解引用的行为,这样就可以使用迭代器访问链表数据了

    template<class T>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T> Self;

		Node* _node;
		ListIterator(Node* _node)
			:_node(_node)
		{}

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

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

	};
    
    template<class T>
	class list
	{
        void Empty_Init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}
    
		//构造函数
		list()
		{
			Empty_Init();
		}
        
        iterator begin()
		{
			//隐式类型转换
			return _head->_next;
		}

		iterator end()
		{
			//隐式类型转换
			return _head;
		}
	private:
		Node* _head;
		size_t _size;
	};
完善迭代器功能  
operator->的重载

        但是上述代码具有一定的局限性,例如当T为一个结构体A时,*iterator返回的是结构体A,想要访问结构体中的数据还需要用 例如:*(it).a1,但是这样写有点多次一举,因为迭代器it本身就是指向节点的指针,访问数据可以直接使用 ->,例如:it->a1,所以我们还需要将->重载一下

  T* operator->()
 {
    //返回数据的地址
	return &_node->_data;
 }

结构体A存储在节点的_data中,这里返回了_data的地址,如果按照正常的思路进行访问,应该按照如下的方式:it.operator->()->_a1 应该是两个箭头,第一个箭头代表运算符的重载,第二个代表指针解引用访问数据。
但是编译器为了方便查看会进行优化,将两个箭头变成了一个箭头 it->_a1 ,这样直接可以访问

const迭代器

const的本质就是为了禁止对成员进行修改,所以我们只需要const迭代器只需要对非const迭代器稍加修改即可

    template<class T>
	struct ListConstIterator
	{
		typedef ListNode<T> Node;
		typedef ListConstIterator<T> Self;

		Node* _node;
		ListConstIterator(Node* _node)
			:_node(_node)
		{}

		const T& operator*()
		{
			return _node->_data;
		}

		const T* operator->()
		{
			return &_node->_data;
		}

	};

但是这样const迭代器与非const迭代器这两个类的重合度非常高,仅仅是函数返回值前是否加用const修饰的区别,所以我们可以利用模板

    typedef ListIterator<T,T&,T*> iterator;
    typedef ListIterator<T,const T&,const T*> const_iterator;
    ---------------------------------
    template<class T,class Ref,class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;

		Node* _node;
		ListIterator(Node* _node)
			:_node(_node)
		{}

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

		Ptr operator->()
		{
			return &_node->_data;
		}
		//前置++
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

		Self operator++(int)
		{
			Self tmp(_node);
			_node = _node->_next;
			return tmp;
		}
	};
完整代码:
#include<iostream>
using namespace std;
namespace zyq
{
	template<class T>
	struct ListNode
	{
		ListNode* _next;
		ListNode* _prev;
		T _data;

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

	//template<class T>
	//struct ListIterator
	//{
	//	typedef ListNode<T> Node;
	//	typedef ListIterator<T> Self;

	//	Node* _node;
	//	ListIterator(Node* _node)
	//		:_node(_node)
	//	{}

	//	T& operator*()
	//	{
	//		return _node->_data;
	//	}

	//     T* operator->()
	//	{
	//		return &_node->_data;
	//	}

	//	//前置++
	//	Self& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}

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

	//	bool operator!=(const Self& it)
	//	{
	//		return !(_node == it._node);
	//	}

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

	//};

	//template<class T>
	//struct ListConstIterator
	//{
	//	typedef ListNode<T> Node;
	//	typedef ListConstIterator<T> Self;

	//	Node* _node;
	//	ListConstIterator(Node* _node)
	//		:_node(_node)
	//	{}

	//	const T& operator*()
	//	{
	//		return _node->_data;
	//	}

	//	const T* operator->()
	//	{
	//		return &_node->_data;
	//	}

	//	//前置++
	//	 Self& operator++()
	//	{
	//		_node = _node->_next;
	//		return *this;
	//	}

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

	//	bool operator!=(const Self& it)
	//	{
	//		return !(_node == it._node);
	//	}

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

	template<class T,class Ref,class Ptr>
	struct ListIterator
	{
		typedef ListNode<T> Node;
		typedef ListIterator<T, Ref, Ptr> Self;

		Node* _node;
		ListIterator(Node* _node)
			:_node(_node)
		{}

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

		Ptr operator->()
		{
			return &_node->_data;
		}
		//前置++
		Self& operator++()
		{
			_node = _node->_next;
			return *this;
		}

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

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

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

	};
	template<class T>
	class list
	{
	public:
		typedef ListNode<T> Node;
		//typedef ListIterator<T> iterator;
		//typedef ListConstIterator<T> const_iterator;
		typedef ListIterator<T,T&,T*> iterator;
		typedef ListIterator<T,const T&,const T*> const_iterator;

		iterator begin()
		{
			//隐式类型转换
			return _head->_next;
		}

		iterator end()
		{
			//隐式类型转换
			return _head;
		}

		const_iterator begin() const
		{
			//隐式类型转换
			return _head->_next;
		}

		const_iterator end() const
		{
			//隐式类型转换
			return _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> lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		//赋值运算符重载
		list<T>& operator=(list<T> lt)
		{
			swap(lt);
			return *this;
		}

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

		size_t size()
		{
			return _size;
		}

		/*void push_back(const T& x)
		{
			Node* newnode = new Node(x);
			Node* tail = _head->_prev;

			tail->_next = newnode;
			newnode->_prev = tail;
			newnode->_next = _head;
			_head->_prev = newnode;
			_size++;
		}*/

		void push_back(const T& x)
		{
			insert(end()  , x);
		}

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

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

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

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

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = cur;
			cur->_prev = newnode;
			_size++;
		}

		iterator erase(iterator pos)
		{
			Node* prev = pos._node->_prev;
			Node* next = pos._node->_next;
			prev->_next = next;
			next->_prev = prev;
			delete pos._node;
			_size--;
			return next;
		}

	private:
		Node* _head;
		size_t _size;
	};

	template<class T>
	void PrintList(const list<T>& clt)
	{
		typename list<T>::const_iterator it = clt.begin();
		while (it != clt.end())
		{
			cout << *it << " ";
			it++;
		}
		cout << endl;
	}

	void testlist1()
	{
		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;
		/*lt.push_back(9);
		lt.pop_front();*/
		PrintList(lt);
		list<int> lt1(lt);
		PrintList(lt1);
		list<int> lt2;
		lt2 = lt;
		PrintList(lt2);
	}

	struct A
	{
		int _a1;
		int _a2;
		A(int a1 = 0, int a2 = 0)
			:_a1(a1)
			, _a2(a2)
		{}
	};

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

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

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

相关文章

Kubernetes(k8s)监控与报警:Prometheus + Grafana + Alertmanager(超详细)

Kubernetes&#xff08;k8s&#xff09;监控与报警&#xff1a;Prometheus Grafana Alertmanager&#xff08;超详细&#xff09; 1、部署环境2、基本概念简介2.1、Prometheus简介2.2、Grafana简介2.3、Alertmanager简介2.4、Prometheus GrafanaAlertmanager监控架构 3、Pro…

品牌发言稿怎么写?纯干货

品牌发言稿的重要性不言而喻&#xff0c;它不仅代表着品牌形象&#xff0c;更是沟通品牌与消费者、合作伙伴的桥梁。如何撰写一篇高质量的品牌发言稿&#xff0c;成为许多品牌关注的焦点。伯乐网络传媒十多年文案撰写经验&#xff0c;今天就来给大家讲一讲。 一、品牌发言稿的组…

关系(三)利用python绘制相关矩阵图

关系&#xff08;三&#xff09;利用python绘制相关矩阵图 相关矩阵图&#xff08;Correlogram&#xff09;简介 相关矩阵图既可以分析每对变量之间的相关性&#xff0c;也可以分析单变量的分布情况。相关性以散点图的形式可视化&#xff0c;对角线用直方图/密度图表示每个变量…

面试字节被挂了

分享一个面试字节的经历。 1、面试过程 一面&#xff1a;上来就直接"做个题吧"&#xff0c;做完之后&#xff0c;对着简历上一个项目聊&#xff0c;一直聊到最后&#xff0c;还算比较正常。 二面&#xff1a;做自我介绍&#xff0c;花几分钟聊了一个项目&#xff…

Notepad++软件安装及配置说明

Notepad是 Windows操作系统下的一套文本编辑器&#xff0c;有完整的中文化接口及支持多国语言编写的功能。 Notepad功能比 Windows自带记事本强大&#xff0c;除了可以用来制作一般的纯文字说明文件&#xff0c;也十分适合编写计算机程序代码。Notepad不但可以显示行号&#xf…

精酿啤酒的未来:创新与传统的碰撞

随着精酿啤酒的兴起&#xff0c;越来越多的人开始关注这一领域的发展趋势。精酿啤酒作为啤酒中的一种新兴类别&#xff0c;其未来发展将受到创新与传统的碰撞和影响。在这其中&#xff0c;Fendi Club啤酒屋作为精酿啤酒的代表性场所&#xff0c;将继续发挥其重要的作用。 首先&…

windows10系统下TP-LINK万兆网卡属性配置高级说明

文章目录 打开配置属性说明ARP Offload&#xff1a;ARP地址解析协议卸载Downshift retries:降档重试次数Energy-Efficient Ethernet:高能效以太网Flow Control:流量控制Interrupt Moderation:中断调整Interrupt Moderation Rate:中断调节率IPv4 Checksum Offload:IPv4校验和卸载…

好看的短袖品牌有哪些?不会穿搭的男生有这几件短袖就够了

很多朋友都经常跟我说&#xff0c;自己买回来的衣服要么就是太长要么就是太短&#xff0c;甚至还有一些质量很差的衣服。而主要的原因就是目前市面上有太多未经过细节优化的衣裤&#xff0c;同时鱼龙混杂的市场也让大家十分容易选择到这类衣服。 而最近天气也逐渐转热&#xf…

java算法day46 | 动态规划part08 ● 139.单词拆分 ● 关于多重背包,你该了解这些! ● 背包问题总结篇!

139.单词拆分 完全背包问题&#xff0c;只不过装入背包时需要附加一个判断条件。 class Solution {public boolean wordBreak(String s, List<String> wordDict) {boolean[] dpnew boolean[s.length()1];dp[0]true;for(int j1;j<s.length();j){for(int i0;i<wordD…

【深度学习】最强算法之:深度Q网络(DQN)

深度Q网络 1、引言2、深度Q网络2.1 定义2.2 原理2.3 实现方式2.4 算法公式2.5 代码示例 3、总结 1、引言 小屌丝&#xff1a;鱼哥&#xff0c; 马上清明小长假了&#xff0c; 你这准备去哪里玩啊&#xff1f; 小鱼&#xff1a;哪也不去&#xff0c;在家待着 小屌丝&#xff1a…

Java 开发篇+一个简单的数据库管理系统ZDB

说明&#xff1a;本文供数据库爱好者和初级开发人员学习使用 标签&#xff1a;数据库管理系统、RDBMS、Java小程序、Java、Java程序 系统&#xff1a;Windows 11 x86 CPU &#xff1a;Intel IDE &#xff1a;IntelliJ IDEA Community Edition 2024 语言&#xff1a;Java语言 标…

“AI+信创”两翼齐飞,实在智能全面加速自主可控实在智能RPA

近日&#xff0c;实在智能牵手华为昇腾、摩尔线程在信创领域展开紧密合作&#xff0c;共同加速推进AI和信创产业创新发展。 华为昇腾与实在智能达成昇腾原生大模型联合创新合作&#xff0c;基于华为昇腾AI自主创新软硬件平台全栈技术、实在智能自研RPA基础大模型解决方案能力&a…

简单好用高效的视频补帧软件:Squirrel-RIFE

Squirrel-RIFE&#xff0c;轻松实现高效补帧&#xff0c;让您的视频画面瞬间流畅升级&#xff01;- 精选真开源&#xff0c;释放新价值。 概览 在观看视频内容的过程中&#xff0c;尤其是面对复杂多变的动画场景或高速运动镜头时&#xff0c;观众时常会遭遇视频帧率不足所引发…

算法中的二阶差分

众所周知&#xff0c;在往区间的每一个数都加上一个相同的数k&#xff0c;进行n次后会得到一个新的数列&#xff0c;如果每次加都循环区间挨个数加上k&#xff0c;这样时间复杂度无疑是O(n^2)&#xff0c;很高。这时可以采用一阶差分就可解决&#xff0c;这里默认会一阶差分&am…

物联网行业趋势——青创智通

工业物联网解决方案-工业IOT-青创智通 随着科技的不断进步和应用场景的日益扩大&#xff0c;物联网行业呈现出迅猛发展的势头。作为当今世界最具前瞻性和战略意义的领域之一&#xff0c;物联网行业的趋势和未来发展值得深入探讨。 ​一、物联网行业正逐渐实现全面普及。随着物…

鸿蒙ArkUI开发实战:制作一个【简单计数器】

构建第一个页面 使用文本组件 工程同步完成后&#xff0c;在 Project 窗口&#xff0c;点击 entry > src > main > ets > pages &#xff0c;打开 Index.ets 文件&#xff0c;可以看到页面由 Row 、 Column 、 Text 组件组成。 index.ets 文件的示例如下&#xff1…

飞机降落(区间问题)

思路&#xff1a; 受P1803 凌乱的yyy / 线段覆盖的启发。 对于这道题&#xff0c;我的第一想法不是dfs&#xff0c;而是把它看作区间来看&#xff0c;分别就是【t&#xff0c;tl】和【td&#xff0c;tdl】。先按照结束时间排序&#xff0c;先用第一个飞机不延迟降落的时间a[0…

制造业智能化一体式I/O模块的集成与应用案例分享

在现代制造业中&#xff0c;智能化一体式I/O模块的应用已经成为提升生产效率、优化工艺流程的关键技术之一。这种一体化I/O模块的主要功能在于作为PLC&#xff08;可编程逻辑控制器&#xff09;系统的扩展接口&#xff0c;以满足多样化的输入输出需求。本文将通过一个实际案例&…

DFS-0与异或问题,有奖问答,飞机降落

代码和解析 #include<bits/stdc.h> using namespace std; int a[5][5]{{1,0,1,0,1}}; //记录图中圆圈内的值&#xff0c;并初始化第1行 int gate[11]; //记录10个逻辑门的一种排列 int ans; //答案 int logic(int x, int y, int op){…

麒麟系统下安装qt5.9.1后不能输入中文

引言 在虚拟机上安装麒麟系统后,安装了qt5.9.1,只能输入英文和数字不能输入中文注释,编译的程序也不能输入中文。 原因 安装后的麒麟系统自带搜狗输入法,原本可以输入中文,但是qt5.9.1缺少支持搜狗输入法的fcitx插件。所以qt5.9.1中不能输入中文。 解决方法 安装fcit…