【C++】unordered系列容器的封装

在这里插入图片描述

你很自由
充满了无限可能
这是很棒的事
我衷心祈祷你可以相信自己
无悔地燃烧自己的人生
-- 东野圭吾 《解忧杂货店》

unordered系列的封装

  • 1 unordered_map 和 unordered_set
  • 2 改造哈希桶
    • 2.1 模版参数
    • 2.2 加入迭代器
  • 3 上层封装
    • 3.1 unordered_set
    • 3.2 unordered_map
  • 4 面试题分析
  • Thanks♪(･ω･)ﾉ谢谢阅读！！！
  • 下一篇文章见！！！

1 unordered_map 和 unordered_set

unordered系列的库是以哈希桶为底层的容器，其是用来快速寻找指定数据。这里主要介绍unordered_map和unordered_set。

unordered_map
  1. unordered_map是用来储存 <key , value>键值对的容器，可以通过Key快速寻找到其对应的value,注意Key和value的类型可以不一样。并且key不可更改，value可以更改！
  2. unordered_map内部并不是按照特定顺序储存的，而是按照key转换得到的数组下标来进行存储，因此内部是无序的！
  3. unordered_map通过key查找元素比map快非常多！！！但对应迭代的速度比较慢。
  4. unordered_map允许[ ]下标访问！
  5. unordered_map只有正向迭代器！没有反向迭代器！
unordered_set
  1. unordered_set是只储存key值的容器！和set相似，用来去重或者判断是否存在！
  2. unordered_set内部并不是按照特定顺序储存的，而是按照key转换得到的数组下标来进行存储，因此内部是无序的！
    1. unordered_set通过key查找元素比set快非常多！！！但对应迭代的速度比较慢。
  4. unordered_set不提供[ ]下标访问！
  5. unordered_set只有正向迭代器！没有反向迭代器！

他们都提供以下接口：

迭代器
函数功能介绍
begin返回unordered_map第一个元素的迭代器
end返回unordered_map最后一个元素下一个位置的迭代器
cbegin返回unordered_map第一个元素的const迭代器
cend返回unordered_map最后一个元素下一个位置的const迭代器
功能函数
函数功能介绍
iterator find(const K& key)返回key在哈希桶中的位置
size_t count(const K& key)返回哈希桶中关键码为key的键值对的个数
insert向容器中插入键值对
erase删除容器中的键值对
void clear()清空容器中有效元素个数
void swap(unordered_map&)交换两个容器中的元素
桶操作
函数功能介绍
size_t bucket_count()const返回哈希桶中桶的总个数
size_t bucket_size(size_t n)const返回n号桶中有效元素的总个数
size_t bucket(const K& key)返回元素key所在的桶号

接下来我们就来实现这些功能！

2 改造哈希桶

2.1 模版参数

unordered_map 和 unordered_set的底层是开散列版本的哈希表（哈希桶），但是他们两个储存的数据却不一样：一个是键值对pair<k , v> , 一个是键值key。所以为了可以让哈希桶适配，就要进行泛型编程的改造，增加模版参数。由上层的unordered_map 和 unordered_set控制底层的哈希桶存储什么数据，因此我们需要添加一个class T模版参数，供上层决定储存什么数据。与之对应的，从数据中获取key的仿函数。
这样加上将转换key为size_t的仿函数，共用四个模版参数：

  1. class k : 表明键值key的类型，这是最基本的。
  2. class T: 储存的数据类型：pair<k , v> 或 key。
  3. class KeyOfT: 如何从T中获取key，这是很关键的，是我感觉最巧妙的一环，通过仿函数来适配不同类型，太妙了！
  4. class HashFunc:将key值转换为size_t的数组下标。

通过这四个模版参数，就可以通过传入对应的参数来保证适配！（迭代器我们后续来实现）

template<class K, class T, class KeyOfT, class Hash>
class HashTable
{
public:
	typedef HashNode<T> Node;
	iterator begin()
	{}
	iterator end()
	{}
	const_iterator begin() const 
	{}
	const_iterator end() const 
	{}
	
	HashTable()
		:hs(),
		kot()
	{
		_table.resize(10, nullptr);
		_n = 0;
	}
	//插入数据
	pair<iterator, bool> insert(const T kv)
	{}
	//删除
	bool erase(const K& key)
	{}
	//查找
	iterator find(const K& key)
	{}
private:
	//底层是一个指针数组
	vector<Node*> _table;
	//有效数量
	size_t _n;
	//仿函数
	Hash hs;
	KeyOfT kot;
};

我们的模版参数修改之后，我们的函数体也要进行改造，不能直接写死，要符合泛型编程：

函数基本都是修改了原本的cur->_kv。first 变为 kot(cur->_kv)，通过仿函数来获取key值，并且返回值设置为迭代器。这样无论我们传入的是pair<k , v> 或 key，都可以通过仿函数获取对应的key值！下面给出插入函数的代码，其余函数的改造类似！

插入函数 
//插入数据
pair<iterator, bool> insert(const T kv)
{
	iterator it = find(kot(kv));
	if (it != end())
		return make_pair(it, false);

	//扩容
	if (_n == _table.size() * 0.7)
	{
		//直接把原本的节点移动到新的table中即可
		vector<Node*> newtable(2 * _table.size());
		//遍历整个数组
		for (int i = 0; i < _table.size(); i++)
		{
			if (_table[i])
			{
				Node* cur = _table[i];
				while (cur)
				{
					//获取数据
					Node* next = cur->_next;
					//计算新的映射
					//kot(cur->_kv) 来获取 T 中的key
					size_t hashi = hs(kot(cur->_kv)) % newtable.size();
					//进行头插
					cur->_next = newtable[hashi];
					newtable[hashi] = cur;

					cur = next;
				}

			}
		}
		_table.swap(newtable);
	}
	//首先寻找到合适下标
	size_t hashi = hs(kot(kv)) % _table.size();
	//进行头插
	Node* newnode = new Node(kv);

	newnode->_next = _table[hashi];
	_table[hashi] = newnode;
	++_n;

	return make_pair(iterator(newnode , this), true);
}

2.2 加入迭代器

实现封装一定少不了迭代器!!!迭代器可是强大的武器，有了迭代器就可以使用基于范围的for循环，还可以通过迭代器来访问修改数据。

那么我们就要来写一个迭代器，来供我们使用。

哈希表的迭代器和之前写过的迭代器有所不同，我们来看奥：我们搭建一个基本框架:

  1. 首先我们需要一个节点指针，这是迭代器中的关键元素，用来访问数据
  2. 然后我们的迭代器其要支持++运算，可以移动到下一个节点。移动规则：当前桶没走完就移动到下一个元素， 当前桶走完了就移动到下一个桶的第一个元素，而移动到下一个桶需要哈希表表,所以内部需要有一个哈希表
  3. 还要提供基本的!= == * ->运算。
  4. 注意构造函数要使用const HashTable* ht低权限，因为我们不会对其修改，还要避免上层传入``const HashTable* `,所以要做好预防！
template<class Ref , class Ptr>
struct _HTIterator
{
	typedef _HTIterator<Ref, Ptr> Self;
	//成员
	Node* _node;
	//哈希表
	const HashTable* _pht;
	//构造函数
	_HTIterator(Node* node, const HashTable* ht)
		:_node(node),
		_pht(ht)
	{}
	//++
	Self& operator++()
	{
	}
	//判断很好写
	bool operator!=(const Self& s)
	{
		return _node != s._node;
	}
	bool operator==(const Self& s)
	{
		return _node == s._node;
	}
	Ref operator*() const
	{
		return _node->_kv;
	}
	Ptr operator->() const
	{
		return &_node->_kv;
	}
};

如果我们将迭代器正常放在哈希表的外面，会发现报错：编译器不认识 HashTable,很正常，因为HashTable在其后面才进行定义，所以我们可以在迭代器之前加一个HashTable前置声明！或者使用内部类，把迭代器放HashTable内部就好了！

然后我们就来解决这个++的问题：

  1. 如果当前桶还没有走到最后，就要移动到下一个节点，使用cur = cur ->next即可！
  2. 如果走完当前桶了（next指针是nullptr时），就要向后寻找下一个桶了。
  3. 如果找到了就继续进行，没有找到，说明走完了
//++
Self& operator++()
{
	Hash hs;
	KeyOfT kot;
	//++
	//当前桶没走完就移动到下一个 桶走完了就移动到下一个桶 
	if (_node->_next) _node = _node->_next;
	else
	{
		//桶走完了就移动到下一个桶
		size_t i = hs(kot(_node->_kv)) % _pht->_table.size();
		i++;

		for (; i < _pht->_table.size(); i++)
		{
			if (_pht->_table[i])
				break;
		}
		//走完循环有两种可能，要进行判断
		if (i == _pht->_table.size())
			_node = nullptr;
		else
		{
			_node = _pht->_table[i];
		}
	}

	return *this;
}

这样我们的迭代器就完成了，再在hashtable中实例化普通迭代器和const迭代器：

//迭代器
typedef _HTIterator<T&, T*> iterator;
//const 迭代器
typedef _HTIterator<const T&, const T*> const_iterator;

然后加入我们begin()和end(）函数

  1. begin()：从哈希表的第一个桶开始寻找，找到桶中的第一个元素
  2. end() : 设置为空就可以

iterator begin()
{
	for (size_t i = 0; i < _table.size(); i++)
	{
		if (_table[i])
			return iterator(_table[i], this);
	}
	return iterator(nullptr, this);
}

iterator end()
{
	return iterator(nullptr, this);
}

const_iterator begin() const 
{
	for (size_t i = 0; i < _table.size(); i++)
	{
		if (_table[i])
			return const_iterator(_table[i], this);
	}
	return const_iterator(nullptr, this);
}

const_iterator end() const 
{
	return const_iterator(nullptr, this);
}

这样底层就实现好了，接下来我们开始在上层做动作！

3 上层封装

底层的哈希桶我们已经改造完毕了，接下来就是在上层来调用：

3.1 unordered_set

先来看unordered_set，其底层要注意：

  1. unordered_set储存是key值，注意不可修改！要设置为const变量
  2. 使用仿函数SetKeyOfT来从T中获取Key值
  3. 上层要通过给对应的哈希函数
  4. 大部分函数直接调用底层Hashtable中的函数就可以！
  5. 在实例化迭代器时，需要使用typename关键字来明确指出iterator是一个类型，而不是一个变量或者别的什么。

这样我们可以搭建起一个框架

//仿函数
template<class K>
struct SetKeyOfT
{
	const K operator()(const K& k)
	{
		return k;
	}
};

template<class K ,class Hash = HashFunc<K>>
class my_unoerder_set
{
public:
	//迭代器
	typedef typename HashTable<K, const K, SetKeyOfT<K>, Hash >::iterator iterator;
	typedef typename HashTable<K, const K, SetKeyOfT<K>, Hash >::const_iterator const_iterator;

	pair<iterator , bool> insert(const K& k)
	{
		return _table.insert(k);
	}
	iterator find(const K& k)
	{
		return _table.find(k);
	}
	bool erase(const K& k)
	{
		return _table.erase(k);
	}
	iterator begin()
	{
		return _table.begin();
	}
	iterator end()
	{
		return _table.end();
	}
	const_iterator begin() const
	{
		return _table.begin();
	}
	const_iterator end() const 
	{
		return _table.end();
	}
private:
	HashTable<K,const K, SetKeyOfT<K> , Hash > _table;
};

这样就设置好了，我们来测试一下：

void test_set1()
{
	my_unoerder_set<string> S;
	vector<string> arr = { "sort" , "hello" , "JLX" , "Hi" };
	for (auto e : arr)
	{
		S.insert(e);
	}
	my_unoerder_set<string>::iterator it = S.begin();
	cout << "-------while循环遍历--------" << endl;
	while (it != S.end())
	{
		//(*it)++;
		std::cout << *it << endl;
		++it;
	}
	cout << "-------基于范围的for循环--------" << endl;
	for (auto e : S)
	{
		//e++;
		cout << e << endl;
	}
	cout << "-------查找\"hello\"--------" << endl;
	cout << *(S.find("hello")) << endl;
}

测试结果：
在这里插入图片描述
完美，这样unordered_set就完成了，当然还可以继续完善功能函数，其他的函数比较简单就不加赘述。

3.2 unordered_map

继续来看unordered_map：

  1. 与unordered_set不同，unordered_map里面储存的是pair<k , v>，而且注意k值不能修改所以要传入pair<const k , v>!
  2. 使用仿函数MapKeyOfT来从T中获取Key值
  3. 上层要通过给对应的哈希函数
  4. 大部分函数直接调用底层Hashtable中的函数就可以！
  5. 在实例化迭代器时，需要使用typename关键字来明确指出iterator是一个类型，而不是一个变量或者别的什么。
  6. 另外要额外实现[ ]操作：非常简单，[ ]的运算规则是：如果对应key已经存在，就返回其value值。不存在就进行插入，value设置为初始值，所以直接调用Insert函数就可以，因为Insert函数不会插入重复的数据并且会返回对应的迭代器！
//仿函数
template<class K , class V>
struct MapKeyOfT
{
	const K& operator()(const pair<K , V>& kv)
	{
		return kv.first;
	}
};

template<class K , class V, class Hash = HashFunc<K>>
class my_unoerder_map
{
public:
	//迭代器
	typedef typename HashTable< K, pair<const K, V>, MapKeyOfT<K, V> , Hash>::iterator iterator;
	typedef typename HashTable< K, pair<const K, V>, MapKeyOfT<K, V> , Hash>::const_iterator const_iterator;

	pair<iterator, bool> insert(pair<const K, V> kv)
	{
		return _table.insert(kv);
	}
	iterator find(const K& k)
	{
		return _table.find(k);
	}
	bool erase(const K& k)
	{
		return _table.erase(k);
	}
	iterator begin()
	{
		return _table.begin();
	}
	iterator end()
	{
		return _table.end();
	}
	//[]操作
	V& operator[](const K& k)
	{
		pair<iterator, bool> it = insert(make_pair( k , V() ));
		return it.first->second;
	}

private:
	HashTable<K, pair<const K , V>, MapKeyOfT<K , V> , Hash> _table;
};

我们来进行一下测试奥：

void test_unordered_map()
{
	my_unoerder_map<string, int> countMap;
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
	"苹果", "香蕉", "苹果", "香蕉","苹果","草莓", "苹果","草莓" };

	for (auto& e : arr)
	{
		countMap[e]++;
	}
	my_unoerder_map<string, int>::iterator it = countMap.begin();
	while (it != countMap.end())
	{
		//(*it).first += 2;
		cout << (*it).first << ':' << (*it).second << endl;
		++it;
	}
}

运行结果：
在这里插入图片描述
完美！！！

4 面试题分析

哈希切割

给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？

错误回答：通过哈希表，遍历一遍该文件，获取到每个IP地址出现的次数，再遍历一遍哈希表，得到出现次数的IP地址。
…
这样的回答是对哈希理解的不够深导致的，我们看题目条件：超过100G大小的log file！哈希中负载因子一般为0.5 ~ 0.7，所以会有很多空间是浪费的，文件本身已经100G了，可想而知这个哈希表会有多大了！
我们可以使用

  1. 分治法：将大文件分割成多个小文件，每个文件分别统计IP出现次数，然后再合并结果。
  2. 哈希分区：根据IP地址的哈希值将日志分布到多个小文件中，每个小文件分别处理，最后合并结果。
  3. 外部排序：如果内存有限，可以使用外部排序算法来处理大量数据。布隆过滤器：如果内存非常有限，可以使
  4. 用布隆过滤器来估算IP地址的出现频率，但可能会有误报。
    …

正确回答(分治 + 哈希)：

  1. 预处理：如果日志文件格式允许，可以使用命令行工具（如awk，grep，sort等）对日志进行预处理，提取IP地址并排序。
  2. 分治：将大文件分割成多个小文件，每个文件大小可以基于内存限制来决定。
  3. 计数：对于每个小文件，使用哈希表统计IP出现次数。合并：将所有小文件的统计结果合并起来。这里可以使
  4. 用外部排序或者分布式系统来进行合并。
  5. 找到最频繁的IP：在合并结果中找到出现次数最多的IP。

与上题条件相同，如何找到top K的IP？如何直接用Linux系统命令实现？

正确答案：

  1. 提取IP地址：使用awk或grep等工具从日志文件中提取IP地址。
  2. 排序：使用sort命令对提取出的IP地址进行排序(文件过大可以分成若干个文件进行排序)。
  3. 计数：使用uniq -c命令来计数每个IP地址出现的次数。
  4. 排序并获取Top K：再次使用sort命令，这次是根据计数进行排序，并使用head -n K来获取前K个结果。
  5. 对应指令：awk '{print $1}' log_file | sort | uniq -c | sort -nr | head -n K
位图应用

给定100亿个整数，设计算法找到只出现一次的整数？

正确回答：可以使用位图（Bitmap）数据结构来有效地解决问题。位图是一种数据结构，用于存储与处理布尔值，其中每个值只占用一个位（bit）的空间。位图中是一个整型数组，每个整型可以储存32个比特位

  1. 初始化位图：创建一个位图，其大小足以表示所有可能出现的整数。需要一个大小为10亿位的位图。
  2. 标记出现次数：遍历所有的整数，对于每个整数，将其在位图中对应的位设置为1。如果整数再次出现，则将其在位图中对应的位设置为-1,在出现就不进行处理。这样，最终位图中为1的位对应的整数就是只出现一次的整数。
  3. 收集结果：遍历位图，找到所有为1的位，这些位对应的整数就是只出现一次的整数。

给两个文件，分别有100亿个整数，我们只有1G内存，如何找到两个文件交集？

正确回答：

  • 方法一：分治法 + 哈希分桶
    1. 分治法：将每个文件分割成多个小文件，每个小文件的大小可以基于内存限制来决定。
    2. 哈希分桶：使用哈希函数将文件中的整数分布到多个桶中。对于每个桶，可以在内存中处理两个文件中的整数，找到交集。
    3. 合并结果：将所有小文件的交集结果合并起来，得到最终的交集
  • 方法二：外部排序
    1. 排序：分别对两个文件进行外部排序。由于内存限制，每次只处理一部分数据。
    2. 合并：使用外部归并排序的思想，逐步合并两个文件中的数据（取整数出现次数少的那部分），找到交集。

位图应用变形：1个文件有100亿个int，1G内存，设计算法找到出现次数不超过2次的所有整数

正确回答：

  • 方法一：分治法 + 哈希表
    1. 分治法：将大文件分割成多个小文件，每个小文件的大小可以基于内存限制来决定。
    2. 计数：对于每个小文件，使用哈希表（如std::unordered_map）来计数每个整数出现的次数。
    3. 过滤：遍历哈希表，将出现次数不超过2次的整数输出到结果文件中。
    4. 合并结果：将所有小文件的结果合并起来，得到最终的输出。
  • 方法二：哈希分桶
    1. 哈希分桶：使用哈希函数将文件中的整数分布到多个桶中。
    2. 计数：对于每个桶，可以在内存中使用哈希表来计数每个整数出现的次数。
    3. 过滤：遍历哈希表，将出现次数不超过2次的整数输出到结果文件中。
    4. 合并结果：将所有桶的结果合并起来，得到最终的输出

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！

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

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

相关文章

C++基础22 字符串与字符数组及其相关操作

C++基础22 字符串与字符数组及其相关操作

这是《C算法宝典》C基础篇的第22节文章啦~ 如果你之前没有太多C基础&#xff0c;请点击&#x1f449;C基础&#xff0c;如果你C语法基础已经炉火纯青&#xff0c;则可以进阶算法&#x1f449;专栏&#xff1a;算法知识和数据结构&#x1f449;专栏&#xff1a;数据结构啦 ​ 目…
阅读更多...
c++重定向输出和输出（竞赛讲解）

c++重定向输出和输出（竞赛讲解）

1.命令行重定向 在命令行中指定输出文件 指令 .\重定向学习.exe > 1.txt 效果 命令行输入和输出 指令 .\重定向学习.exe < 2.txt > 1.txt 效果 代码 #include<bits/stdc++.h> using namespace std; int n; int main(){cin>>n;for(int i=0;i<n;i…
阅读更多...
4、SSD主控

4、SSD主控

简述 主控是个片上系统&#xff0c;由硬件和固件组成一个功能完整的系统&#xff1b;上文所述的FTL就属于主控的固件范畴。主控闪存构成了整个SSD&#xff0c;在闪存确定的情况下&#xff0c;主控就反映了各家SSD的差异。实时上各家SSD的差异也主要反应在主控上&#xff0c;毕…
阅读更多...
VMware虚拟机Ubuntu网络有线线缆已拔出问题

VMware虚拟机Ubuntu网络有线线缆已拔出问题

1、问题描述 VMware虚拟机Ubuntu不能联网&#xff0c;打开设置中&#xff0c;网络显示“有线 线缆已拔出”。 2、查看虚拟网络连接 查看主机的网络连接&#xff0c;确保虚拟网络已启用。 3、启动虚拟机网络服务 打开主机的 ‘服务’&#xff08;winr&#xff0c;运行框中输入…
阅读更多...
46.修复HOOK对代码造成的破坏

46.修复HOOK对代码造成的破坏

上一个内容&#xff1a;45.使用hook点链表实现指定跳转 以 45.使用hook点链表实现指定跳转 它的代码为基础进行修改 此代码已实现无敌与秒杀功能 HOOKPOINT.h文件里的修改 #pragma oncetypedef struct CPUINFO {unsigned eflags;unsigned edi;unsigned esi;unsigned ebp;un…
阅读更多...
PCL从理解到应用【03】KDTree 原理分析 | 案例分析 | 代码实现

PCL从理解到应用【03】KDTree 原理分析 | 案例分析 | 代码实现

前言 本文分析KDTree的原理&#xff0c;集合案例深入理解&#xff0c;同时提供源代码。 三个案例&#xff1a;K近邻搜索、半径内近邻搜索、近似最近邻搜索。方法对比&#xff0c;如下表所示&#xff1a; 特性K近邻搜索半径内近邻搜索近似最近邻搜索描述查找K个最近邻点查找指…
阅读更多...
Linux系统(CentOS)安装Mysql5.7.x

Linux系统(CentOS)安装Mysql5.7.x

安装准备&#xff1a; Linux系统(CentOS)添加防火墙、iptables的安装和配置 请访问地址&#xff1a;https://blog.csdn.net/esqabc/article/details/140209894 1&#xff0c;下载mysql安装文件&#xff08;mysql-5.7.44为例&#xff09; 选择Linux通用版本64位&#xff08;L…
阅读更多...
[深度学习]卷积理解

[深度学习]卷积理解

单通道卷积 看这个的可视化就很好理解了 https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md 多通道卷积 当输入有多个通道时,卷积核需要拥有相同的通道数. 假设输入有c个通道,那么卷积核的每个通道分别于相应的输入数据通道进行卷积,然后将得到的特征图对…
阅读更多...
说明本文档目录是软件开发梳理需求常见问题QA文档，方便客户看，也方便我们的售前人员，需求分析人员，ui设计师，原型绘图人员，思维导图绘图人员查看。

说明本文档目录是软件开发梳理需求常见问题QA文档，方便客户看，也方便我们的售前人员，需求分析人员，ui设计师，原型绘图人员，思维导图绘图人员查看。

https://doc.youyacao.com/117/2150 说明 本文档目录是软件开发梳理需求常见问题QA文档&#xff0c;方便客户看&#xff0c;也方便我们的售前人员&#xff0c;需求分析人员&#xff0c;ui设计师&#xff0c;原型绘图人员&#xff0c;思维导图绘图人员查看。 提示 本内容客户…
阅读更多...
【ABB】控制器语言切换

【ABB】控制器语言切换

【ABB】控制器语言切换 操作流程演示 操作流程 点击【菜单】点击【Control Panel】点击【Language】点击【Chinese】点击【OK】此时会弹出弹窗&#xff0c;点击【YES】此时控制器会重启&#xff0c;重启完成就是中文了 演示 点击【菜单】 点击【Control Panel】 点击【Langua…
阅读更多...
4.2 投影

4.2 投影

一、投影和投影矩阵 我们以下面两个问题开始&#xff0c;问题一是为了展示投影是很容易视觉化的&#xff0c;问题二是关于 “投影矩阵”&#xff08;projection matrices&#xff09;—— 对称矩阵且 P 2 P P^2P P2P。 b \boldsymbol b b 的投影是 P b P\boldsymbol b Pb。…
阅读更多...
涂山璟无缘奥运会

涂山璟无缘奥运会

“涂山璟无缘奥运会”在那片被浪漫与幻想包裹的剧集世界里&#xff0c;涂山璟与小夭的故事&#xff0c;如同夏日里的一缕清风&#xff0c;温柔而又坚定。当爱情以纯粹的形式展现&#xff0c;一个简单的愿望——亲手摘取湖中的海棠花&#xff0c;便成为了两人情感交流的甜蜜桥梁…
阅读更多...
吉洪诺夫正则化随笔

吉洪诺夫正则化随笔

前言 前几天在回顾压缩感知中的特征选择与LASSO回归发现了这个Tikhonov regularization&#xff0c;查了一下叫个如题的名字。先来浅说一下正则化这玩意&#xff1a;正则化&#xff08;Regularization&#xff09;是一种用来防止模型过拟合&#xff08;Overfitting&#xff09…
阅读更多...
【数据库了解与学习】

【数据库了解与学习】

1.下载所需版本安装包 1.1将所需文件压缩包以及安装包放在你选择的任意一盘&#xff0c;新建一个没有文字和空格的文件夹 1.2双击打开安装包&#xff0c;选择Custom自定义模式然后点击右下方的Next 1.4三连点击1&#xff0c;再点击箭头出现3&#xff0c;选中3出现4&#xff0c;…
阅读更多...
AJAX-day1：

AJAX-day1：

注&#xff1a;文件布局&#xff1a; 一、AJAX的概念&#xff1a; AJAX是浏览器与服务器进行数据通信的技术 >把数据变活 二、AJAX的使用&#xff1a; 使用axios库&#xff0c;与服务器进行数据通信 基于XMLHttpRequest封装&#xff0c;代码简单 Vue,React项目使用 学习…
阅读更多...
day04-matplotlib入门

day04-matplotlib入门

matplotlib Matplotlib 提供了一个套面向绘图对象编程的 API接口 是一款用于数据可视化的 Python 软件包&#xff0c;支持跨平台运行 它能够根据 NumPyndarray 数组来绘制 2D(3D) 图像&#xff0c;它使用简单、代码清晰易懂&#xff0c;深受广大技术爱好 者喜爱。 实列&…
阅读更多...
云计算渲染时代：选择Blender或KeyShot进行高效渲染

云计算渲染时代：选择Blender或KeyShot进行高效渲染

在云渲染技术日益成熟的背景下&#xff0c;挑选一款贴合项目需求的3D渲染软件显得尤为关键。当前&#xff0c;Blender与KeyShot作为业界领先的全能渲染解决方案&#xff0c;广受推崇。它们虽皆能创造出令人信服的逼真视觉效果&#xff0c;但在特色功能上各有所长。本篇文章旨在…
阅读更多...
加装德国进口高精度主轴 智能手机壳「高质量高效率」钻孔铣槽

加装德国进口高精度主轴 智能手机壳「高质量高效率」钻孔铣槽

在当前高度智能化的社会背景下&#xff0c;智能手机早已成为人们生活、工作的必备品&#xff0c;智能手机壳作市场需求量巨大。智能手机壳的加工过程涉及多个环节&#xff0c;包括钻孔和铣槽等。钻孔要求精度高、孔位准确&#xff0c;而铣槽则需要保证槽位规整、深度适宜。这些…
阅读更多...
利用C语言实现三子棋游戏

利用C语言实现三子棋游戏

文章目录 1.游戏界面2.游戏内容2.1 棋盘类型2.2棋盘的初始化2.3 打印棋盘的界面展示 3.游戏操作3.1 玩家操作3.2 电脑操作3.3 胜负判定 4.代码整合 1.游戏界面 无论写任何程序&#xff0c;我们都需要先去了解它的大概框架&#xff0c;这里我们先把它的初始界面写出来。一个游戏…
阅读更多...
自动化设备上位机设计 二

自动化设备上位机设计 二

目录 一 设计原型 二 后台代码 一 设计原型 二 后台代码 namespace 自动化上位机设计 {public partial class Form1 : Form{public Form1(){InitializeComponent();timer1.Enabled true;timer1.Tick Timer1_Tick;}private void Timer1_Tick(object? sender, EventArgs e)…
阅读更多...
最新文章

Copyright @ 2022~2023