【C++】─篇文章带你熟练掌握 map 与 set 的使用

news2024/11/23 4:12:32

在这里插入图片描述

目录

  • 一、关联式容器
  • 二、键值对
  • 三、pair
    • 3.1 pair的常用接口说明
      • 3.1.1 [无参构造函数](https://legacy.cplusplus.com/reference/utility/pair/pair/)
      • 3.1.2 [有参构造函数 / 拷贝构造函数](https://legacy.cplusplus.com/reference/utility/pair/pair/)
      • 3.1.3 [有参构造函数](https://legacy.cplusplus.com/reference/utility/pair/pair/)
      • 3.1.4 [make_pair()函数](https://legacy.cplusplus.com/reference/utility/make_pair/)
  • 四、树形结构的关联式容器
    • 4.1 标准库中的set
      • 4.1.1 set的介绍
      • 4.1.2 set的常用接口说明
        • 4.1.2.1 set对象的常见构造
          • 4.1.2.1.1 [无参构造函数](https://legacy.cplusplus.com/reference/set/set/set/)
          • 4.1.2.1.2 [有参构造函数(使用迭代器进行初始化构造)](https://legacy.cplusplus.com/reference/set/set/set/)
          • 4.1.2.1.3 [拷贝构造函数](https://legacy.cplusplus.com/reference/set/set/set/)
        • 4.1.2.2 set iterator 的使用
          • 4.1.2.2.1 [begin()函数](https://legacy.cplusplus.com/reference/set/set/begin/) + [end()函数](https://legacy.cplusplus.com/reference/set/set/end/)
          • 4.1.2.2.2 [rbegin()函数](https://legacy.cplusplus.com/reference/set/set/rbegin/) + [rend()函数](https://legacy.cplusplus.com/reference/set/set/rend/)
        • 4.1.2.3 set对象的容量操作
          • 4.1.2.3.1 [size()函数](https://legacy.cplusplus.com/reference/set/set/size/)
          • 4.1.2.3.2 [empty()函数](https://legacy.cplusplus.com/reference/set/set/empty/)
        • 4.1.2.4 set对象的增删查改及访问
          • 4.1.2.4.1 [insert()函数](https://legacy.cplusplus.com/reference/set/set/insert/)
          • 4.1.2.4.2 [erase()函数](https://legacy.cplusplus.com/reference/set/set/erase/)
          • 4.1.2.4.3 [swap()函数](https://legacy.cplusplus.com/reference/set/set/swap/)
          • 4.1.2.4.4 [clear()函数](https://legacy.cplusplus.com/reference/set/set/clear/)
          • 4.1.2.4.5 [find()函数](https://legacy.cplusplus.com/reference/set/set/find/)
          • 4.1.2.4.6 [count()函数](https://legacy.cplusplus.com/reference/set/set/count/)
          • 4.1.2.4.7 [lower_bound()函数](https://legacy.cplusplus.com/reference/set/set/lower_bound/)
          • 4.1.2.4.8 [upper_bound()函数](https://legacy.cplusplus.com/reference/set/set/upper_bound/)
          • 4.1.2.4.9 [equal_range()函数](https://legacy.cplusplus.com/reference/set/set/equal_range/)
    • 4.2 标准库中的multiset
      • 4.2.1 multiset的介绍
      • 4.2.2 multiset的常用接口说明
        • 4.2.2.1 multiset对象的常用构造
          • 4.2.2.1.1 [无参构造函数](https://legacy.cplusplus.com/reference/set/multiset/multiset/)
          • 4.2.2.1.2 [有参构造函数(使用迭代器进行初始化构造)](https://legacy.cplusplus.com/reference/set/multiset/multiset/)
          • 4.2.2.1.3 [拷贝构造函数](https://legacy.cplusplus.com/reference/set/multiset/multiset/)
        • 4.2.2.2 multiset iterator 的使用
          • 4.2.2.2.1 [begin()函数](https://legacy.cplusplus.com/reference/set/multiset/begin/) + [end()函数](https://legacy.cplusplus.com/reference/set/multiset/end/)
          • 4.2.2.2.2 [rbegin()函数](https://legacy.cplusplus.com/reference/set/multiset/rbegin/) + [rend()函数](https://legacy.cplusplus.com/reference/set/multiset/rend/)
        • 4.2.2.3 multiset 对象的容量操作
          • 4.2.2.3.1 [size()函数](https://legacy.cplusplus.com/reference/set/multiset/size/)
          • 4.2.2.3.2 [empty()函数](https://legacy.cplusplus.com/reference/set/multiset/empty/)
        • 4.2.2.4 multiset 对象的增删查改及访问
          • 4.2.2.4.1 [insert()函数](https://legacy.cplusplus.com/reference/set/multiset/insert/)
          • 4.2.2.4.2 [erase()函数](https://legacy.cplusplus.com/reference/set/multiset/erase/)
          • 4.2.2.4.3 [swap()函数](https://legacy.cplusplus.com/reference/set/multiset/swap/)
          • 4.2.2.4.4 [clear()函数](https://legacy.cplusplus.com/reference/set/multiset/clear/)
          • 4.2.2.4.5 [find()函数](https://legacy.cplusplus.com/reference/set/multiset/find/)
          • 4.2.2.4.6 [count()函数](https://legacy.cplusplus.com/reference/set/multiset/count/)
          • 4.2.2.4.7 [lower_bound()函数](https://legacy.cplusplus.com/reference/set/multiset/lower_bound/)
          • 4.2.2.4.8 [upper_bound()函数](https://legacy.cplusplus.com/reference/set/multiset/upper_bound/)
          • 4.2.2.4.9 [equal_range()函数](https://legacy.cplusplus.com/reference/set/multiset/equal_range/)
    • 4.3 标准库中的map
      • 4.3.1 map的介绍
      • 4.3.2 map的常用接口说明
        • 4.3.2.1 map对象的常用构造
          • 4.3.2.1.1 [无参构造函数](https://legacy.cplusplus.com/reference/map/map/map/)
          • 4.3.2.1.2 [有参构造函数(使用迭代器进行初始化构造](https://legacy.cplusplus.com/reference/map/map/map/)
          • 4.3.2.1.3 [拷贝构造函数](https://legacy.cplusplus.com/reference/map/map/map/)
        • 4.3.2.2 map iterator 的使用
          • 4.3.2.2.1 [begin()函数](https://legacy.cplusplus.com/reference/map/map/begin/) + [end()函数](https://legacy.cplusplus.com/reference/map/map/end/)
          • 4.3.2.2.2 [rbegin()函数](https://legacy.cplusplus.com/reference/map/map/rbegin/) + [rend()函数](https://legacy.cplusplus.com/reference/map/map/rend/)
        • 4.3.2.3 map对象的容量操作
          • 4.3.2.3.1 [size()函数](https://legacy.cplusplus.com/reference/map/map/empty/)
          • 4.3.2.3.2 [empty()函数](https://legacy.cplusplus.com/reference/map/map/empty/)
        • 4.3.2.4 map对象的增删查改及访问
          • 4.3.2.4.1 [insert()函数](https://legacy.cplusplus.com/reference/map/map/insert/)
          • 4.3.2.4.2 [erase()函数](https://legacy.cplusplus.com/reference/map/map/erase/)
          • 4.3.2.4.3 [swap()函数](https://legacy.cplusplus.com/reference/map/map/swap/)
          • 4.3.2.4.4 [clear()函数](https://legacy.cplusplus.com/reference/map/map/clear/)
          • 4.3.2.4.5 [find()函数](https://legacy.cplusplus.com/reference/map/map/find/)
          • 4.3.2.4.6 [count()函数](https://legacy.cplusplus.com/reference/map/map/count/)
          • 4.3.2.4.7 [lower_bound()函数](https://legacy.cplusplus.com/reference/map/map/lower_bound/)
          • 4.3.2.4.8 [upper_bound()函数](https://legacy.cplusplus.com/reference/map/map/upper_bound/)
          • 4.3.2.4.9 [equal_range()函数](https://legacy.cplusplus.com/reference/map/map/equal_range/)
          • 4.3.2.4.10 [operator[]](https://legacy.cplusplus.com/reference/map/map/operator%5B%5D/)
    • 4.4 标准库中的multimap
      • 4.4.1 multimap的介绍
      • 4.4.2 multimap的常用接口说明
        • 4.4.2.1 multimap对象的常用构造
          • 4.4.2.1.1 [无参构造函数](https://legacy.cplusplus.com/reference/map/multimap/multimap/)
          • 4.4.2.1.2 [有参构造函数(使用迭代器进行初始化构造)](https://legacy.cplusplus.com/reference/map/multimap/multimap/)
          • 4.4.2.1.3 [拷贝构造函数](https://legacy.cplusplus.com/reference/map/multimap/multimap/)
        • 4.4.2.2 multimap iterator 的使用
          • 4.4.2.2.1 [begin()函数](https://legacy.cplusplus.com/reference/map/multimap/begin/) + [end()函数](https://legacy.cplusplus.com/reference/map/multimap/end/)
          • 4.4.2.2.2 [rbegin()函数](https://legacy.cplusplus.com/reference/map/multimap/rbegin/) + [rend()函数](https://legacy.cplusplus.com/reference/map/multimap/rend/)
        • 4.4.2.3 multimap 对象的容量操作
          • 4.4.2.3.1 [size()函数](https://legacy.cplusplus.com/reference/map/multimap/size/)
          • 4.4.2.3.2 [empty()函数](https://legacy.cplusplus.com/reference/map/multimap/empty/)
        • 4.4.2.4 multimap对象的增删查改及访问
          • 4.4.2.4.1 [insert()函数](https://legacy.cplusplus.com/reference/map/multimap/insert/)
          • 4.4.2.4.2 [erase()函数](https://legacy.cplusplus.com/reference/map/multimap/erase/)
          • 4.4.2.4.3 [swap()函数](https://legacy.cplusplus.com/reference/map/multimap/swap/)
          • 4.4.2.4.4 [clear()函数](https://legacy.cplusplus.com/reference/map/multimap/clear/)
          • 4.4.2.4.5 [find()函数](https://legacy.cplusplus.com/reference/map/multimap/find/)
          • 4.4.2.4.6 [count()函数](https://legacy.cplusplus.com/reference/map/multimap/count/)
          • 4.4.2.4.7 [lower_bound()函数](https://legacy.cplusplus.com/reference/map/multimap/lower_bound/)
          • 4.4.2.4.8 [upper_bound()函数](https://legacy.cplusplus.com/reference/map/multimap/upper_bound/)
          • 4.4.2.4.9 [equal_range()函数](https://legacy.cplusplus.com/reference/map/multimap/equal_range/)
  • 五、map和set在OJ中的应用
    • 5.1 [692. 前K个高频单词](https://leetcode.cn/problems/top-k-frequent-words/description/)
    • 5.2 [349. 两个数组的交集](https://leetcode.cn/problems/intersection-of-two-arrays/submissions/)
  • 结尾

一、关联式容器

在初阶阶段,我们已经接触过STL中的部分容器,比如:vectorlistdequeforward_list(C++11)等,这些容器统称为序列式容器,因为其底层为线性序列的数据结构,里面存储的是元素本身。那什么是关联式容器?它与序列式容器有什么区别?关联式容器也是用来存储数据的,与序列式容器不同的是,其里面存储的是<key, value>结构的键值对,在数据检索时比序列式容器效率更高


二、键值对

用来表示具有一一对应关系的一种结构,该结构中一般只包含两个成员变量keyvaluekey代表键值,value表示与key对应的信息。比如:现在要建立一个英汉互译的字典,那该字典中必然有英文单词与其对应的中文含义,而且,英文单词与其中文含义是一一对应的关系,即通过该应该单词,在词典中就可以找到与其对应的中文含义。

SGI-STL中关于键值对的定义:

using namespace std;

template <class T1, class T2>
struct pair
{
	typedef T1 first_type;
	typedef T2 second_type;
	T1 first;
	T2 second;
	pair() : first(T1()), second(T2())
	{}
	pair(const T1& a, const T2& b) : first(a), second(b)
	{}
};

三、pair

pair的文档介绍

pair 是 C++ 标准库中的一个模板类,用于存储两个对象的有序对。通常情况下,pair 用于将两个不同类型的对象组合成一个单元,并且允许这两个对象分别访问。

3.1 pair的常用接口说明

3.1.1 无参构造函数

pair();
int main()
{
	pair <string, double> p;                     
	cout << p.first << "  " << p.second << endl;

	return 0;
}

在这里插入图片描述


3.1.2 有参构造函数 / 拷贝构造函数

template<class U, class V> pair (const pair<U,V>& pr);
当参数不匹配时为有参构造函数
当参数匹配时为拷贝构造函数

在这里插入图片描述


3.1.3 有参构造函数

pair (const first_type& a, const second_type& b);
int main()
{
	pair <string, double> p("Love", 5.20);   
	cout << p.first << " " << p.second << endl;;

	return 0;
}

在这里插入图片描述


3.1.4 make_pair()函数

template <class T1, class T2>
	pair<T1,T2> make_pair (T1 x, T2 y);
template <class T1, class T2>
pair<T1, T2> make_pair(T1 x, T2 y)
{
    return (pair<T1, T2>(x, y));
}

在这里插入图片描述


四、树形结构的关联式容器

根据应用场景的不桶,STL总共实现了两种不同结构的管理式容器:树型结构与哈希结构。树型结构的关联式容器主要有四种:mapsetmultimapmultiset。这四种容器的共同点是:使用平衡搜索树(即红黑树)作为其底层结果,容器中的元素是一个有序的序列。下面一依次介绍每一个容器。

4.1 标准库中的set

4.1.1 set的介绍

set的文档介绍

  1. set是按照一定次序存储元素的容器
  2. 在set中,元素的value也标识它(value就是key,类型为T),并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const),但是可以从容器中插入或删除它们。
  3. 在内部,set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格弱排序准则进行排序。
  4. set容器通过key访问单个元素的速度通常比unordered_set容器慢,但它们允许根据顺序对子集进行直接迭代。
  5. set在底层是用二叉搜索树(红黑树)实现的。

set的模板参数列表介绍
在这里插入图片描述
T: set中存放元素的类型,实际在底层存储<value, value>的键值对。

Compare:set中元素默认按照小于来比较

Alloc:set中元素空间的管理方式,使用STL提供的空间配置器管理(目前不需要掌握)


4.1.2 set的常用接口说明

4.1.2.1 set对象的常见构造
4.1.2.1.1 无参构造函数
set (const key_compare& comp = key_compare());
int main()
{
	set<int> s;

	return 0;
}

在这里插入图片描述


4.1.2.1.2 有参构造函数(使用迭代器进行初始化构造)
template <class InputIterator>
  set (InputIterator first, InputIterator last,
       const key_compare& comp = key_compare());
int main()
{
	string s("I Love Y");

	set<int> ss(s.begin(), s.end());

	for (auto e : ss)
	{
		cout << e << ' ';
	}

	cout << endl;
	return 0;
}

在这里插入图片描述


4.1.2.1.3 拷贝构造函数
set (const set& x);
int main()
{
	string s("I Love Y");

	set<int> ss1(s.begin(), s.end());
	set<int> ss2(ss1);

	for (auto e : ss2)
	{
		cout << e << ' ';
	}

	cout << endl;
	return 0;
}

在这里插入图片描述


4.1.2.2 set iterator 的使用
4.1.2.2.1 begin()函数 + end()函数
 	  iterator begin();
const_iterator begin() const;
获取第一个数据位置的iterator/const_iterator

	  iterator end();
const_iterator end() const;
获取最后一个数据的下一个位置的iterator/const_iterator

在这里插入图片描述

int main()
{
	string s("I Love Y");

	set<int> ss1(s.begin(), s.end());

	set<int>::iterator it = ss1.begin();
	while (it != ss1.end())
	{
		cout << *it << ' ';
		++it;
	}

	cout << endl;
	return 0;
}

4.1.2.2.2 rbegin()函数 + rend()函数
 	  reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
获取最后一个数据位置的reverse_iterator/const_reverse_iterator 

	  reverse_iterator rend();
const_reverse_iterator rend() const;
获取第一个数据前一个位置的reverse_iterator/const_reverse_iterator 
int main()
{
	string s("I Love Y");

	set<int> ss1(s.begin(), s.end());

	set<int>::reverse_iterator it = ss1.rbegin();
	while (it != ss1.rend())
	{
		cout << *it << ' ';
		++it;
	}

	cout << endl;
	return 0;
}

在这里插入图片描述


4.1.2.3 set对象的容量操作
4.1.2.3.1 size()函数
size_type size() const;	获取数据个数

在这里插入图片描述


4.1.2.3.2 empty()函数
bool empty() const;		判断是否为空
int main()
{
	set<int> ss;
	cout << ss.empty() << endl;

	string s("I Love Y");
	set<int> ss1(s.begin(), s.end());

	cout << ss1.empty() << endl;

	return 0;
}

在这里插入图片描述


4.1.2.4 set对象的增删查改及访问
4.1.2.4.1 insert()函数
pair<iterator,bool> insert (const value_type& val);
在set中插入一个元素val:

若set中有这个元素,插入失败,则返回一个pair对象
pair.first=原来val元素位置的迭代器,pair.second = false

若set中没有这个元素,插入成功,则返回一个pair对象
pair.first=新插入val元素位置的迭代器,pair.second = true

iterator insert (iterator position, const value_type& val);
不建议使用:在position位置插入一个val,并返回插入元素位置的迭代器

template <class InputIterator>
  	void insert (InputIterator first, InputIterator last);
插入一段迭代器区间的元素
int main()
{
	set<int> s;
	string ss("I Love Y");

	/*pair<iterator, bool> insert(const value_type & val);
	在set中插入一个元素val:*/
	pair<set<int>::iterator, bool> ret;
	for (int i = 0; i < 14; i += 2)
	{
		ret = s.insert(i % 10);
		cout << "插入元素:" << *ret.first 
			<< "  是否成功:" << ret.second << endl;
	}

	for (auto e : s)
	{
		cout << e << ' ';
	}
	cout << endl;

	// 插入一段迭代器区间的元素
	s.insert(ss.begin(), ss.end());

	for (auto e : s)
	{
		cout << e << ' ';
	}
	cout << endl;

	return 0;
}

在这里插入图片描述


4.1.2.4.2 erase()函数
void erase (iterator position);
删除position位置的元素

size_type erase (const value_type& val);
删除元素val并返回删除val的个数

void erase (iterator first, iterator last);
删除一段迭代器区间内的元素
int main()
{
	set<int> s;

	for (int i = 0; i < 10; i++)
	{
		s.insert(i);
	}

	for (auto e : s)
	{	cout << e << ' ';	}
	cout << endl;

	set<int>::iterator it = s.begin();
	s.erase(it);

	for (auto e : s)
	{	cout << e << ' ';	}
	cout << endl;

	// 删除元素val并返回val的个数
	s.erase(5);

	for (auto e : s)
	{	cout << e << ' ';	}
	cout << endl;

	// 删除一段迭代器区间内的元素
	s.erase(++s.begin() , --s.end());

	for (auto e : s)
	{	cout << e << ' ';	}
	cout << endl;

	return 0;
}

在这里插入图片描述


4.1.2.4.3 swap()函数
void swap (set& x);
交换两个set的数据空间
int main()
{
	set<int> s1;
	set<int> s2;

	for (int i = 1; i < 10; i += 2)
	{	s1.insert(i);	}

	for (int i = 0; i < 10; i += 2)
	{	s2.insert(i);	}

	for (auto e : s1)
	{	cout << e << ' ';	}
	cout << endl;

	for (auto e : s2)
	{	cout << e << ' ';	}
	cout << endl;

	s1.swap(s2);

	for (auto e : s1)
	{	cout << e << ' ';	}
	cout << endl;

	for (auto e : s2)
	{	cout << e << ' ';	}
	cout << endl;

	return 0;
}

在这里插入图片描述


4.1.2.4.4 clear()函数
void clear();
清除set中的有效数据
int main()
{
	set<int> s;

	for (int i = 1; i < 10; i += 2)
	{	
		s.insert(i);	
	}

	s.clear();

	return 0;
}

在这里插入图片描述


4.1.2.4.5 find()函数
iterator find (const value_type& val) const;
返回set中为val元素位置的迭代器
int main()
{
	set<int> s;

	for (int i = 1; i < 10; i += 2)
	{
		s.insert(i);
	}

	set<int>::iterator it = s.find(5);

	cout << *it << endl;

	return 0;
}

在这里插入图片描述


4.1.2.4.6 count()函数
size_type count (const value_type& val) const;
返回set中为val元素的个数
由于set并不允许相同的元素存在
所以set中所有元素的个数都是1
int main()
{
	set<int> s;

	for (int i = 1; i < 10; i += 2)
	{
		s.insert(i);
	}

	for (auto e : s)
	{
		cout << e << "的个数:" << s.count(e) << endl;
	}

	return 0;
}

在这里插入图片描述


4.1.2.4.7 lower_bound()函数
iterator lower_bound (const value_type& val) const;
返回第一个 >= val 对象位置的迭代器
int main()
{
	set<int> s;

	// 10 20 30 40 50
	for (int i = 1; i < 6; i++)
	{
		s.insert(i*10);
	}

	set<int>::iterator it = s.lower_bound(30);

	cout << *it << endl;

	return 0;
}

在这里插入图片描述


4.1.2.4.8 upper_bound()函数
iterator upper_bound (const value_type& val) const;
返回第一个 > val 对象位置的迭代器
int main()
{
	set<int> s;

	// 10 20 30 40 50
	for (int i = 1; i < 6; i++)
	{
		s.insert(i * 10);
	}

	set<int>::iterator it = s.upper_bound(30);

	cout << *it << endl;

	return 0;
}

在这里插入图片描述


4.1.2.4.9 equal_range()函数
pair<iterator,iterator> equal_range (const value_type& val) const;
返回一个pair对象
pair.first = 第一个 >= val 对象位置的迭代器
pair.second = 第一个 > val 对象位置的迭代器
int main()
{
	set<int> s;

	// 10 20 30 40 50
	for (int i = 1; i < 6; i++)
	{
		s.insert(i * 10);
	}

	pair<set<int>::iterator, set<int>::iterator> 
		p = s.equal_range(30);

	cout << *p.first << " " << * p.second << endl;

	return 0;
}

在这里插入图片描述


4.2 标准库中的multiset

4.2.1 multiset的介绍

multiset的文档介绍

  1. multiset是按照特定顺序存储元素的容器,其中元素是可以重复的。
  2. multiset元素的值不能在容器中进行修改(因为元素总是const的),但可以从容器中插入或删除。
  3. 在内部,multiset中的元素总是按照其内部比较规则(类型比较)所指示的特定严格弱排序准则进行排序。
  4. multiset容器通过key访问单个元素的速度通常比unordered_multiset容器慢,但当使用迭代器遍历时会得到一个有序序列。
  5. multiset底层结构为二叉搜索树(红黑树)。

注意:

  1. mtltiset的插入接口中只需要插入即可
  2. 与set的区别是,multiset中的元素可以重复,set是中value是唯一的
  3. 使用迭代器对multiset中的元素进行遍历,可以得到有序的序列
  4. multiset中的元素不能修改
  5. 在multiset中找某个元素,时间复杂度为 O ( l o g 2 N ) O(log_2 N) O(log2N)
  6. multiset的作用:可以对元素进行排序

4.2.2 multiset的常用接口说明

注意:multiset的接口与set的接口基本相似,可以参考set的使用,那么下面multiset将不会进行演示使用。

4.2.2.1 multiset对象的常用构造
4.2.2.1.1 无参构造函数
multiset (const key_compare& comp = key_compare());

4.2.2.1.2 有参构造函数(使用迭代器进行初始化构造)
template <class InputIterator>
	multiset (InputIterator first, InputIterator last,
        const key_compare& comp = key_compare());

4.2.2.1.3 拷贝构造函数
multiset (const multiset& x);

4.2.2.2 multiset iterator 的使用
4.2.2.2.1 begin()函数 + end()函数
 	  iterator begin();
const_iterator begin() const;
获取第一个数据位置的iterator/const_iterator

	  iterator end();
const_iterator end() const;
获取最后一个数据的下一个位置的iterator/const_iterator

4.2.2.2.2 rbegin()函数 + rend()函数
 	  reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
获取最后一个数据位置的reverse_iterator/const_reverse_iterator 

	  reverse_iterator rend();
const_reverse_iterator rend() const;
获取第一个数据前一个位置的reverse_iterator/const_reverse_iterator 

4.2.2.3 multiset 对象的容量操作
4.2.2.3.1 size()函数
size_type size() const;
获取数据个数

4.2.2.3.2 empty()函数
bool empty() const;		判断是否为空

4.2.2.4 multiset 对象的增删查改及访问
4.2.2.4.1 insert()函数
iterator insert (const value_type& val);
在multiset中插入一个元素val,并返回插入元素位置的迭代器
由于multiset可以存在相同的元素,那么就不存在插入失败的情况

iterator insert (iterator position, const value_type& val);
不建议使用:在position位置插入一个val,并返回插入元素位置的迭代器

template <class InputIterator>
  	void insert (InputIterator first, InputIterator last);
插入一段迭代器区间的元素

4.2.2.4.2 erase()函数
void erase (iterator position);
删除position位置的元素

size_type erase (const value_type& val);
删除元素val并返回删除val的个数

void erase (iterator first, iterator last);
删除一段迭代器区间内的元素

4.2.2.4.3 swap()函数
void swap (multiset& x);
交换两个multiset的数据空间

4.2.2.4.4 clear()函数
void clear();
清除multiset中的有效数据

4.2.2.4.5 find()函数
iterator find (const value_type& val) const;
返回multiset中为val元素位置的迭代器

4.2.2.4.6 count()函数
size_type count (const value_type& val) const;	
返回multiset中为val元素的个数,multiset中可以存在相同的元素

4.2.2.4.7 lower_bound()函数
iterator lower_bound (const value_type& val) const;
返回第一个 >= val 对象位置的迭代器

4.2.2.4.8 upper_bound()函数
iterator upper_bound (const value_type& val) const;
返回第一个 > val 对象位置的迭代器

4.2.2.4.9 equal_range()函数
pair<iterator,iterator> equal_range (const value_type& val) const;
返回一个pair对象
pair.first = 第一个 >= val 对象位置的迭代器
pair.second = 第一个 > val 对象位置的迭代器

4.3 标准库中的map

4.3.1 map的介绍

map的文档介绍

  1. map是关联容器,它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
  2. 在map中,键值key通常用于排序和惟一地标识元素,而值value中存储与此键值key关联的内容。键值key和值value的类型可能不同,并且在map的内部,key与value通过成员类型value_type绑定在一起,为其取别名称为pair:typedef pair<const key, T> value_type;
  3. 在内部,map中的元素总是按照键值key进行比较排序的。
  4. map中通过键值访问单个元素的速度通常比unordered_map容器慢,但map允许根据顺序对元素进行直接迭代(即对map中的元素进行迭代时,可以得到一个有序的序列)。
  5. map支持下标访问符,即在[]中放入key,就可以找到与key对应的value。
  6. map通常被实现为二叉搜索树(更准确的说:平衡二叉搜索树(红黑树))。

map的模板参数列表介绍
在这里插入图片描述
key: 键值对中key的类型

T: 键值对中value的类型

Compare: 比较器的类型,map中的元素是按照key来比较的,缺省情况下按照小于来比较,一般情况下(内置类型元素)该参数不需要传递,如果无法比较时(自定义类型),需要用户自己显式传递比较规则(一般情况下按照函数指针或者仿函数来传递)

Alloc:通过空间配置器来申请底层空间,不需要用户传递,除非用户不想使用标准库提供的空间配置器(目前不需要掌握)


4.3.2 map的常用接口说明

4.3.2.1 map对象的常用构造
4.3.2.1.1 无参构造函数
map (const key_compare& comp = key_compare());
int main()
{
	map<int, int> m;

	return 0;
}                                                                                                                                                                                                                   

在这里插入图片描述

4.3.2.1.2 有参构造函数(使用迭代器进行初始化构造
template <class InputIterator>
	map (InputIterator first, InputIterator last,
   		const key_compare& comp = key_compare());

map(有序关联容器)的构造函数通常也不接受其他容器类型的迭代器来直接构造。map 要求它的元素按照键(key)的顺序进行排序,因此在构造时,它期望提供的元素已经按照键的升序排列。

如果尝试使用未排序的迭代器范围(例如,来自 vector 或 list 的迭代器)来构造 map,将会导致编译错误或未定义行为,因为 map 无法保证这些元素的排序。

如果想要从一个容器(如 vector)创建一个 map,你需要确保容器中的元素已经按照键的升序排列,然后你可以使用迭代器范围来构造 map。

int main()
{
	vector<pair<int, int>> v({ {5,5},{13,13},{1,1} });
	sort(v.begin(), v.end());
	map<int,int> m1(v.begin(), v.end());
	map<int, int> m2(m1.begin(), m1.end());

	return 0;
}

在这里插入图片描述


4.3.2.1.3 拷贝构造函数
map (const map& x);
int main()
{
	map<int, int> m1;
	m1.insert(make_pair(1, 1));
	m1.insert(make_pair(2, 2));

	map<int, int> m2(m1);

	return 0;
}

在这里插入图片描述


4.3.2.2 map iterator 的使用
4.3.2.2.1 begin()函数 + end()函数
 	  iterator begin();
const_iterator begin() const;
获取第一个数据位置的iterator/const_iterator

	  iterator end();
const_iterator end() const;
获取最后一个数据的下一个位置的iterator/const_iterator
int main()
{
	map<int, int> m1;
	m1.insert(make_pair(1, 1));
	m1.insert(make_pair(2, 2));

	map<int, int>::iterator it = m1.begin();
	while(it != m1.end())
	{
		cout << "first:" << it->first 
			<< "  second:" << it->second << endl;
		++it;
	}
	return 0;
}

在这里插入图片描述


4.3.2.2.2 rbegin()函数 + rend()函数
 	  reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
获取最后一个数据位置的reverse_iterator/const_reverse_iterator 

	  reverse_iterator rend();
const_reverse_iterator rend() const;
获取第一个数据前一个位置的reverse_iterator/const_reverse_iterator 
int main()
{
	map<int, int> m1;
	m1.insert(make_pair(1, 1));
	m1.insert(make_pair(2, 2));

	map<int, int>::reverse_iterator it = m1.rbegin();
	while (it != m1.rend())
	{
		cout << "first:" << it->first
			<< "  second:" << it->second << endl;
		++it;
	}
	return 0;
}

在这里插入图片描述


4.3.2.3 map对象的容量操作
4.3.2.3.1 size()函数
size_type size() const;
获取数据个数
int main()
{
	map<int, int> m1;

	cout << m1.size() << endl;

	m1.insert(make_pair(1, 1));
	m1.insert(make_pair(2, 2));

	cout << m1.size() << endl;

	return 0;
}

在这里插入图片描述


4.3.2.3.2 empty()函数
bool empty() const;		判断是否为空
int main()
{
	map<int, int> m1;

	cout << m1.empty() << endl;

	m1.insert(make_pair(1, 1));
	m1.insert(make_pair(2, 2));

	cout << m1.empty() << endl;

	return 0;
}

在这里插入图片描述


4.3.2.4 map对象的增删查改及访问
4.3.2.4.1 insert()函数
pair<iterator,bool> insert (const value_type& val);
在map中插入键值对val:

若map中有这个键值对,插入失败,则返回一个pair对象
pair.first=原来val位置的迭代器,pair.second = false

若map中没有这个键值对,插入成功,则返回一个pair对象
pair.first=新插入val位置的迭代器,pair.second = true

iterator insert (iterator position, const value_type& val);
不建议使用:在position位置插入一个val,并返回插入键值对位置的迭代器

template <class InputIterator>
  	void insert (InputIterator first, InputIterator last);
插入一段迭代器区间的元素
int main()
{
	map<int,int> m1;

	/*pair<iterator, bool> insert(const value_type & val);
	在set中插入一个元素val:*/
	pair<map<int,int>::iterator, bool> ret;
	for (int i = 0; i < 14; i += 2)
	{
		ret = m1.insert(make_pair(i % 10, i % 10));
		cout << "插入key:" << ret.first->first
			<< "  是否成功:" << ret.second << endl;
	}

	for (auto e : m1)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	// 插入一段迭代器区间的元素
	map<int, int> m2;
	m2.insert(make_pair(520, 520));
	m2.insert(make_pair(1314, 1314));

	cout << "insert前m2中的元素" << endl;
	for (auto e : m2)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	m2.insert(m1.begin(), m1.end());
	cout << "insert后m2中的元素" << endl;
	for (auto e : m2)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	return 0;
}

在这里插入图片描述


4.3.2.4.2 erase()函数
void erase (iterator position);
删除position位置的元素

size_type erase (const value_type& val);
删除元素val并返回删除val的个数

void erase (iterator first, iterator last);
删除一段迭代器区间内的元素
int main()
{
	map<int, int> m1;

	/*pair<iterator, bool> insert(const value_type & val);
	在map中插入一个元素val:*/
	for (int i = 0; i < 14; i += 2)
	{
		m1.insert(make_pair(i % 10, i % 10));
	}

	for (auto e : m1)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	// 删除迭代器位置的元素
	m1.erase(m1.begin());
	for (auto e : m1)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	// 删除元素,并返回元素个数
	m1.erase(6);
	for (auto e : m1)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	// 删除一段迭代器区间内的元素
	m1.erase(++m1.begin(),--m1.end());
	for (auto e : m1)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	return 0;
}

在这里插入图片描述


4.3.2.4.3 swap()函数
void swap (map& x);
交换两个map的数据空间
int main()
{
	map<int,int> m1;

	for (int i = 0; i < 14; i += 2)
	{
		m1.insert(make_pair(i % 10, i % 10));
	}

	cout << "swap前m1中的元素" << endl;

	for (auto e : m1)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	map<int, int> m2;
	m2.insert(make_pair(520, 520));
	m2.insert(make_pair(1314, 1314));

	cout << "swap前m2中的元素" << endl;
	for (auto e : m2)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	m1.swap(m2);

	cout << "swap后m1中的元素" << endl;
	for (auto e : m1)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;

	cout << "swap后m2中的元素" << endl;
	for (auto e : m2)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}
	cout << endl;
	return 0;
}

在这里插入图片描述


4.3.2.4.4 clear()函数
void clear();
清除map中的有效数据
int main()
{
	map<int, int> m;

	for (int i = 0; i < 14; i += 2)
	{
		m.insert(make_pair(i % 10, i % 10));
	}

	m.clear();

	return 0;
}

在这里插入图片描述


4.3.2.4.5 find()函数
	  iterator find (const key_type& k);
const_iterator find (const key_type& k) const;
返回map中为关键码为k位置的迭代器
int main()
{
	map<int, int> m;

	for (int i = 0; i < 14; i += 2)
	{
		m.insert(make_pair(i % 10, i % 10));
	}

	map<int,int>::iterator it = m.find(6);
	cout << "first:" << it->first
		<< "  second:" << it->second << endl;

	return 0;
}

在这里插入图片描述


4.3.2.4.6 count()函数
size_type count (const key_type& k) const;
返回map中为k元素的个数
由于map并不允许相同的元素存在
所以map中所有元素的个数都是1
int main()
{
	map<int, int> m;

	for (int i = 0; i < 14; i += 2)
	{
		m.insert(make_pair(i % 10, i % 10));
	}

	for (auto e : m)
	{
		cout << e.first << "的个数:"
			<< m.count(e.first) << endl;
	}

	return 0;
}

在这里插入图片描述


4.3.2.4.7 lower_bound()函数
	  iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const;
返回第一个关键码 >= k对象位置的iterator/const_iterator
int main()
{
	map<int, int> m;

	for (int i = 0; i < 14; i += 2)
	{
		m.insert(make_pair(i % 10, i % 10));
	}

	map<int, int>::iterator it = m.lower_bound(6);
	cout << "first:" << it->first
		<< "  second:" << it->second << endl;

	return 0;
}

在这里插入图片描述


4.3.2.4.8 upper_bound()函数
	  iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const;
返回第一个关键码 > k 对象位置的iterator/const_iterator
int main()
{
	map<int, int> m;

	for (int i = 0; i < 14; i += 2)
	{
		m.insert(make_pair(i % 10, i % 10));
	}

	map<int, int>::iterator it = m.upper_bound(6);
	cout << "first:" << it->first
		<< "  second:" << it->second << endl;

	return 0;
}

在这里插入图片描述


4.3.2.4.9 equal_range()函数
pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator>             equal_range (const key_type& k);
返回一个pair对象
pair.first = 第一个关键码 >= k 对象位置的iterator/const_iterator
pair.second = 第一个关键码 > k 对象位置的iterator/const_iterator
int main()
{
	map<int, int> m;

	for (int i = 0; i < 14; i += 2)
	{
		m.insert(make_pair(i % 10, i % 10));
	}

	pair<map<int, int>::iterator, map<int, int>::iterator>
		ret = m.equal_range(6);

	cout << "first:" << ret.first->first
		<< "  second:" << ret.first->second << endl;

	cout << "first:" << ret.second->first
		<< "  second:" << ret.second->second << endl;

	return 0;
}

在这里插入图片描述


4.3.2.4.10 operator[]
mapped_type& operator[] (const key_type& k);
返回关键码为key对应的value的引用
mapped_type& operator[] (const key_type& k)
{
	return (*((this->insert(make_pair(k,mapped_type()))).first)).second
}
int main()
{
	map<int, int> m;
	m.insert(make_pair(5, 5));
	// 若map中有这个元素,那么就返回key对应value的引用
	cout << "operator[]:" << m[5] <<endl;

	// 若map中没有这个元素,那么map中将会插入这个元素
	// 使用默认构造初始化value,并返回
	cout << "operator[]:" << m[10] << endl;

	for (auto e : m)
	{
		cout << "first:" << e.first
			<< "  second:" << e.second << endl;
	}

	return 0;
}

在这里插入图片描述


【总结】

  1. map中的的元素是键值对
  2. map中的key是唯一的,并且不能修改
  3. 默认按照小于的方式对key进行比较
  4. map中的元素如果用迭代器去遍历,可以得到一个有序的序列
  5. map的底层为平衡搜索树(红黑树),查找效率比较高 O ( l o g 2 N ) O(log_2 N) O(log2N)
  6. 支持[]操作符,operator[]中实际进行插入查找。

4.4 标准库中的multimap

4.4.1 multimap的介绍

multimap的文档介绍

  1. Multimaps是关联式容器,它按照特定的顺序,存储由key和value映射成的键值对<key,value>,其中多个键值对之间的key是可以重复的。
  2. 在multimap中,通常按照key排序和惟一地标识元素,而映射的value存储与key关联的内容。key和value的类型可能不同,通过multimap内部的成员类型value_type组合在一起,value_type是组合key和value的键值对:typedef pair<const Key, T> value_type;
  3. 在内部,multimap中的元素总是通过其内部比较对象,按照指定的特定严格弱排序标准对key进行排序的。
  4. multimap通过key访问单个元素的速度通常比unordered_multimap容器慢,但是使用迭代器直接遍历multimap中的元素可以得到关于key有序的序列。
  5. multimap在底层用二叉搜索树(红黑树)来实现。
    注意:multimap和map的唯一不同就是:map中的key是唯一的,而multimap中key是可以重复的。

注意:

  1. multimap中的key是可以重复的。
  2. multimap中的元素默认将key按照小于来比较
  3. multimap中没有重载operator[]操作,因为multimap中的key可以重复,如果重载operator[]操作那么找到的结果是未定义的。
  4. 使用时与map包含的头文件相同

4.4.2 multimap的常用接口说明

注意:multimap的接口与map的接口基本相似,可以参考map的使用,那么下面multimap将不会进行演示使用。

4.4.2.1 multimap对象的常用构造
4.4.2.1.1 无参构造函数
multimap (const key_compare& comp = key_compare());

4.4.2.1.2 有参构造函数(使用迭代器进行初始化构造)
template <class InputIterator>
	multimap (InputIterator first, InputIterator last,
        const key_compare& comp = key_compare());

4.4.2.1.3 拷贝构造函数
multimap (const multimap& x);

4.4.2.2 multimap iterator 的使用
4.4.2.2.1 begin()函数 + end()函数
 	  iterator begin();
const_iterator begin() const;
获取第一个数据位置的iterator/const_iterator

	  iterator end();
const_iterator end() const;
获取最后一个数据的下一个位置的iterator/const_iterator

4.4.2.2.2 rbegin()函数 + rend()函数
 	  reverse_iterator rbegin();
const_reverse_iterator rbegin() const;
获取最后一个数据位置的reverse_iterator/const_reverse_iterator 

	  reverse_iterator rend();
const_reverse_iterator rend() const;
获取第一个数据前一个位置的reverse_iterator/const_reverse_iterator 

4.4.2.3 multimap 对象的容量操作
4.4.2.3.1 size()函数
size_type size() const;
获取数据个数

4.4.2.3.2 empty()函数
bool empty() const;		判断是否为空

4.4.2.4 multimap对象的增删查改及访问
4.4.2.4.1 insert()函数
iterator insert (const value_type& val);
在multimap中插入一个键值对val,并返回插入元素位置的迭代器
由于multimap可以存在相同的元素,那么就不存在插入失败的情况

iterator insert (iterator position, const value_type& val);
不建议使用:在position位置插入一个val,并返回插入val位置的迭代器

template <class InputIterator>
  	void insert (InputIterator first, InputIterator last);
插入一段迭代器区间的元素

4.4.2.4.2 erase()函数
void erase (iterator position);
删除position位置的元素

size_type erase (const value_type& val);
删除元素val并返回删除val的个数

void erase (iterator first, iterator last);
删除一段迭代器区间内的元素

4.4.2.4.3 swap()函数
void swap (multiset& x);
交换两个multimap的数据空间

4.4.2.4.4 clear()函数
void clear();
清除multimap中的有效数据

4.4.2.4.5 find()函数
	  iterator find (const key_type& k);
const_iterator find (const key_type& k) const;
返回multimap中关键码为k位置的iterator/const_iterator

4.4.2.4.6 count()函数
size_type count (const key_type& k) const;
返回multimap中关键码为k元素的个数,multimap中可以存在相同的元素

4.4.2.4.7 lower_bound()函数
 	  iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const;
返回第一个关键码 >= k 对象位置的iterator/const_iterator

4.4.2.4.8 upper_bound()函数
	  iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const;
返回第一个关键码 > k 对象位置的iterator/const_iterator

4.4.2.4.9 equal_range()函数
pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator>             equal_range (const key_type& k);
返回一个pair对象
pair.first = 第一个关键码 >= k 对象位置的iterator/const_iterator
pair.second = 第一个关键码 > k 对象位置的iterator/const_iterator

五、map和set在OJ中的应用

5.1 692. 前K个高频单词

给定一个单词列表 words 和一个整数 k ,返回前 k 个出现次数最多的单词。返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率, 按字典顺序 排序。

思路:定义一个对象map<string, int> Mapstring用来记录单词,int用来记录单词出现的次数。遍历vector并在Map中插入,由于Map是按照单词的大小进行比较的,再定义vector<pair<string, int>> tmp并用Map的迭代器区间对tmp进行初始化,再使用单词出现的次数进行排序。需要注意的是pair比较大小的时候是使用pair.first进行比较的,而单词的次数记录在pair.second中,所以我们需要自己写一个仿函数进行比较,单词出现次数多的在前面,单词小的在前面。由于答案只需要单词,那么再定义一个对象vector<string> ans记录答案,访问tmp中前k个元素,访问其中的单词并插入到ans中,最后输出ans完成本题。

class Solution {
public:
    struct Cmp
    {
        bool operator()(const pair<string, int>& p1 ,const pair<string, int>& p2)
        {
            // 出现频率高,且按字典顺序
            return p1.second > p2.second || 
                (p1.second == p2.second && p1.first < p2.first);
        }
    };

    vector<string> topKFrequent(vector<string>& words, int k) {
        map<string, int> Map;
        for(auto x : words)
        {
            Map[x]++;
        }
        // 这里的vector是用来存储pair对象的
        vector<pair<string, int>> tmp(Map.begin(),Map.end());
        sort(tmp.begin() , tmp.end(), Cmp());
        // 需要输出vector<string> ,将pair中的string提取出来
        vector<string> ans;
        for(int i = 0 ; i < k ; i++)
        {
            ans.push_back(tmp[i].first);
        }
        
        return ans;
    }
};

5.2 349. 两个数组的交集

给定两个数组 nums1 和 nums2 ,返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

思路:set能对数据进行排序和去重,定义两个set对象s1,s2,使用nums1nums2的迭代器区间对set进行初始化,定义vector<int> ans记录答案,定义两个set的迭代器it1it2分别记录s1和s2的begin(),对两组数据同时遍历,迭代器指向元素小的++,因为小的元素不可能在和另外一组数据有相同的值,若迭代器指向的元素相等,将元素尾差到ans,有一个迭代器走到最后则说明两组元素不可能再有相同的值了,将ans返回就能完成本道题。

上面是两个数组的交集的思路,而两个数组的差集的思路与交集的思路只有在元素入ans的时候有区别。对两组数据同时遍历,迭代器指向元素小的入ans并且迭代器++,因为小的元素不可能在和另外一组数据有相同的值,若迭代器指向的元素相等,两迭代器同时++,将ans返回就能实现得到两个数组的差集了。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        // 将两分数据进行去重
        set<int> s1(nums1.begin(),nums1.end());
        set<int> s2(nums2.begin(),nums2.end());
        vector<int> ans;

        set<int>::iterator it1 = s1.begin();
        set<int>::iterator it2 = s2.begin();

        while(it1 != s1.end() && it2 != s2.end())
        {
            // 两个数中小的迭代器++
            // 两数相等时将数字尾差到vector中
            // 两迭代器同时++
            if(*it1 > *it2)
            {
                ++it2;
            }
            else if(*it1 < *it2)
            {
                ++it1;
            }
            else
            {
                ans.push_back(*it1);
                ++it1;
                ++it2;
            }
        }
        return ans;
    }
};

结尾

如果有什么建议和疑问,或是有什么错误,大家可以在评论区中提出。
希望大家以后也能和我一起进步!!🌹🌹
如果这篇文章对你有用的话,希望大家给一个三连支持一下!!🌹🌹

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

bootstrap5-学习笔记1-容器+布局+按钮+工具

参考&#xff1a; Bootstrap5 教程 | 菜鸟教程 https://www.runoob.com/bootstrap5/bootstrap5-tutorial.html Spacing Bootstrap v5 中文文档 v5.3 | Bootstrap 中文网 https://v5.bootcss.com/docs/utilities/spacing/ 之前用bootstrap2和3比较多&#xff0c;最近用到了5&a…

【FAS】《Liveness Detection on Face Anti-spoofing》

文章目录 原文总结与评价CNN-RNN vs 三维卷积作者的方法 原文 [1]欧阳文汉.反人脸图像欺诈的活体识别方法研究[D].浙江大学,2020.DOI:10.27461/d.cnki.gzjdx.2020.002675. 总结与评价 时序运动信息与传统的空间纹理信息相结合 基于相位平移的运动放大算法不错 视觉大小细胞…

每日一题《leetcode--LCR 029.循环有序列表的插入》

https://leetcode.cn/problems/4ueAj6/ 这道题整体上想插入数据有三种情况&#xff1a; 1、整个列表是空列表&#xff0c;需要返回插入的结点 2、整个列表只有一个结点&#xff0c;需要在头结点后插入新结点&#xff0c;随机把新结点的next指向头结点 3、整个列表的结点 >1 …

关于飞速(FS)800G光模块的技术问答

随着云计算、物联网&#xff08;IoT&#xff09;和大数据等技术的快速发展&#xff0c;对网络带宽和传输速率的需求越来越大。飞速&#xff08;FS&#xff09;800G光模块的引入旨在满足对高速数据传输的需求&#xff0c;该光模块采用先进的调制解调技术和高密度光电子元件&…

STM32F103VE和STM32F407VE的引脚布局

STM32F103VE vs STM32F407VE 引脚对比表 引脚 STM32F103VE STM32F407VE 备注 1 VSS VSS 地 2 VDD VDD 电源 3 VSSA VSSA 模拟地 4 VDDA VDDA 模拟电源 5 OSC_IN OSC_IN 外部时钟输入 6 OSC_OUT OSC_OUT 外部时钟输出 7 NRST NRST 复位 8 PC13 (GPIO) PC13 (GPIO) GPIO 9 PC14 (…

鸿蒙全栈开发-一文读懂鸿蒙同模块不同模块下的UIAbility跳转详解

前言 根据第三方机构Counterpoint数据&#xff0c;截至2023年三季度末&#xff0c;HarmonyOS在中国智能手机操作系统的市场份额已经提升至13%。短短四年的时间&#xff0c;HarmonyOS就成长为仅次于安卓、苹果iOS的全球第三大操作系统。 因此&#xff0c;对于鸿蒙生态建设而言&a…

依赖注入方式和自动加载原理

依赖注入 Spring提供了依赖注入的功能&#xff0c;方便我们管理和使用各种Bean&#xff0c;常见的方式有&#xff1a; 字段注入&#xff08;Autowired 或 Resource&#xff09;构造函数注入set方法注入 在以往代码中&#xff0c;我们经常利用Spring提供的Autowired注解来实现…

C语言操作UTF-8编码和GBK编码的文件的示例

一、基本介绍 在C语言中&#xff0c;处理文件编码&#xff08;如UTF-8或GBK&#xff09;时&#xff0c;需要注意C标准库中的文件操作函数&#xff08;如fopen, fread, fwrite, fclose等&#xff09;并不直接支持Unicode或特定字符集的编码。这些函数通常处理字节流&#xff0c…

FreeRTOS基础(十一):消息队列

本文将详细全方位的讲解FreeRTOS的消息队列&#xff0c;其实在FreeRTOS中消息队列的重要性也不言而喻&#xff0c;与FreeRTOS任务调度同等重要&#xff0c;因为后面的各种信号量基本都是基于消息队列的。 目录 一、消息队列的简介 1.1 产生的原因 1.2 消息队列的解决办法 …

防病毒克星——白名单可信系统

白名单作为一种网络安全措施&#xff0c;其核心概念在于限制用户只能访问网络所有者定义的受信任内容。这种机制在保护系统免受恶意软件、病毒等攻击方面发挥着重要作用。然而&#xff0c;关于白名单是否可以防病毒的问题&#xff0c;实际上涉及了多个方面的考虑。 首先&#x…

B=2W,奈奎斯特极限定理详解

一直没搞明白奈奎斯特极限定理的含义&#xff0c;网上搜了很久也没得到答案。最近深思几天后&#xff0c;终于有了点心得。顺便吐槽一下&#xff0c;csdn的提问栏目&#xff0c;有很多人用chatgpt秒回这个事&#xff0c;实在是解决不了问题&#xff0c;有时候人的问题大多数都是…

台式机安装Windows 11和Ubuntu 22双系统引导问题

一、基本情况 1.1、硬件情况 电脑有2个NVMe固态硬盘&#xff0c;1个SATA固态硬盘&#xff0c;1个机械硬盘。其中一个NVMe固态硬盘是Windows系统盘&#xff0c;另一个NVMe固态为Windows软件和文件盘&#xff0c;SATA固态硬盘为Ubuntu专用&#xff0c;机械硬盘为数据备份盘。 …

Java | Leetcode Java题解之第136题只出现一次的数字

题目&#xff1a; 题解&#xff1a; class Solution {public int singleNumber(int[] nums) {int single 0;for (int num : nums) {single ^ num;}return single;} }

Ubuntu下安装和配置Redis

目录 1、更新软件包 2、安装Redis 3、启动 Redis临时服务 4、测试Redis服务 5、配置redis服务 6、Redis服务控制命令 1、更新软件包 执行sudo apt-get update更新软件包 sudo apt-get update2、安装Redis 执行sudo apt-get install redis-server 安装命令 sudo apt i…

CLion配置

下载环境&#xff1a;MinGW-w64 - for 32 and 64 bit Windows - Browse Files at SourceForge.net 解压后找一个位置存放&#xff0c;一般放在和ide同一目录&#xff0c;方便查找 个人习惯配置调整&#xff1a; 项目创建 修改ide解码形式 项目右下角一般默认是utf8 文件编码改…

【C++题解】1074 - 小青蛙回来了

问题&#xff1a;1074 - 小青蛙回来了 类型&#xff1a;需要找规律的循环 题目描述&#xff1a; 关于小青蛙爬井的故事&#xff0c;你应该早就听过了&#xff1a;井深10 尺&#xff0c;小青蛙从井底向上爬&#xff0c;每个白天向上爬 3 尺&#xff0c;每个晚上又滑下来 2 尺&…

kafka安装流程

安装kafka前需要安装zookeeper zookeeper安装教程 1.新建一个logs文件夹 2.修改配置文件 3.修改listeners参数 4.以管理员身份启动kafka服务 .\bin\windows\kafka-server-start.bat .\config\server.properties 如果报 输入行太长。 命令语法不正确。 解决方案如下&#x…

全流程透明双语大语言模型MAP-Neo,4.5T 高质量数据训练

前言 近年来&#xff0c;大语言模型 (LLM) 已经成为人工智能领域最热门的研究方向之一&#xff0c;并在各种任务中展现出前所未有的性能。然而&#xff0c;由于商业利益的驱动&#xff0c;许多最具竞争力的模型&#xff0c;例如 GPT、Gemini 和 Claude&#xff0c;其训练细节和…

codeforces round 949 div2

A Turtle and Piggy Are Playing a Game 题目&#xff1a; 思路&#xff1a;输出2的幂次b使得2^b为最大的不超过x的数 代码&#xff1a; #include <iostream>using namespace std;const int N 2e5 10;void solve() {int l, r;cin >> l >> r;if(r % 2) …

哈希表和二维矩阵的结合-2352. 相等行列对(新思路、新解法)

题目链接及描述 . - 力扣&#xff08;LeetCode&#xff09;. - 备战技术面试&#xff1f;力扣提供海量技术面试资源&#xff0c;帮助你高效提升编程技能,轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/equal-row-and-column-pairs/description/?envTypest…