【c++】哈希

Alt

🔥个人主页：Quitecoder

🔥专栏：c++笔记仓

Alt

目录

  • 1. unordered系列关联式容器
    • 1.1 unordered_map
      • 1.2 接口函数
    • 例题
  • 2.哈希概念
    • 2.1哈希冲突
    • 2.2哈希函数
    • 2.3哈希冲突解决
      • 2.3.1线性探测
        • 二次探测
      • 2.3.2开散列
  • 3. 封装
      • 迭代器封装
      • 完整代码：

1. unordered系列关联式容器

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log_2 N log2​N，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同

1.1 unordered_map

在这里插入图片描述

  1. unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
  2. 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
  3. 在内部,unordered_map 没有 对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
  4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
  5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。
  6. 它的迭代器至少是前向迭代器

1.2 接口函数

在这里插入图片描述

operator[]：注意：该函数中实际调用哈希桶的插入操作**，用参数key与V()构造一个默认值往底层哈希桶中插入，如果key不在哈希桶中，插入成功，返回V()，插入失败，说明key已经在哈希桶中，将key对应的value返回**

iterator find(const K& key) 返回key在哈希桶中的位置

size_t count(const K& key) 返回哈希桶中关键码为key的键值对的个数

insert 向容器中插入键值对

erase 删除容器中的键值对

void clear() 清空容器中有效元素个数

void swap(unordered_map&) 交换两个容器中的元素

例题

题目链接：重复N次的元素
题目描述：
在这里插入图片描述

class Solution {
public:int repeatedNTimes(vector<int>& nums) {unordered_map<int,int> mp;int n=nums.size()/2;for(auto e:nums){mp[e]++;}for(auto&e:mp){if(e.second==n){return e.first;}}return -1;}
};

题目链接：两个数组的交集
题目描述：在这里插入图片描述

class Solution {
public:vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {unordered_set<int> s1;unordered_set<int> s2;for(auto e:nums1){s1.insert(e);}for(auto e:nums2){s2.insert(e);}vector<int> res;for(auto e:s1){if(s2.find(e)!=s2.end())res.push_back(e);}return res;}
};

题目链接：两个数组的交集2
题目描述：在这里插入图片描述

class Solution {
public:vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {unordered_map<int,int> mp;vector<int> res;   for(auto e:nums1){mp[e]++;}for(auto e:nums2){if(mp[e]!=0){res.push_back(e);mp[e]--;}}return res;}
};

2.哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即O( l o g 2 N log_2 N log2​N)，搜索的效率取决于搜索过程中元素的比较次数。

理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。
如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素

当向该结构中：

  • 插入元素
    根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
  • 搜索元素
    对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置取元素比较，若关键码相等，则搜索成功

该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称为哈希表(Hash Table)(或者称散列表)

例如：数据集合{1，7，6，4，5，9}；
哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小

在这里插入图片描述
用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？

2.1哈希冲突

对于两个数据元素的关键字 k i k_i ki​和 k j k_j kj​(i != j)，有 k i k_i ki​ != k j k_j kj​，但有：Hash( k i k_i ki​) == Hash( k j k_j kj​)，即：不同关键字通过相同哈希哈数计算出相同的哈希地址，该种现象称为哈希冲突或哈希碰撞

把具有不同关键码而具有相同哈希地址的数据元素称为同义词

2.2哈希函数

引起哈希冲突的一个原因可能是：哈希函数设计不够合理。

哈希函数设计原则：

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
  • 哈希函数计算出来的地址能均匀分布在整个空间中
  • 哈希函数应该比较简单

  1. 直接定址法–(常用)

    • 取关键字的某个线性函数为散列地址：Hash（Key）= A*Key + B
    • 优点：简单、均匀
    • 缺点：需要事先知道关键字的分布情况
    • 使用场景：适合查找比较小且连续的情况

  2. 除留余数法–(常用)
    设散列表中允许的地址数为m，取一个不大于m，但最接近或者等于m的质数p作为除数，
    按照哈希函数：Hash(key) = key% p(p<=m),将关键码转换成哈希地址

2.3哈希冲突解决

解决哈希冲突两种常见的方法是：闭散列和开散列

闭散列：也叫开放定址法，当发生哈希冲突时，如果哈希表未被装满，说明在哈希表中必然还有空位置，那么可以把key存放到冲突位置中的“下一个” 空位置中去

2.3.1线性探测

线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止

  • 插入
      • 通过哈希函数获取待插入元素在哈希表中的位置
      • 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素

在这里插入图片描述

  • 删除
    • 采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素

代码实现：

首先设置每个位置的状态：

enum State
{Empty,Exist,Delete
};

Empty此位置空，Exist此位置已经有元素， Delete元素已经删除

enum State
{Empty,Exist,Delete
};template<class K,class V>
struct HashData
{pair<K, V> _kv;State _state;
};template<class K, class V>
class HashTable
{
public:bool Insert(const pair<K,V>& kv){size_t hashi = kv.first % _tables.size();while (_tables[hashi]._state == Exist){++hashi;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._state = Exist;++_n;}
private:vector<HashData<K, V>> _tables;size_t _n;//有效数据个数
};

hashi 是通过 kv.first % _tables.size() 计算出的初始索引，用于确定存储桶的位置。如果该位置已经被占用（状态为 Exist），则通过线性探测法找到下一个空位置

这里就有一个问题：如果存储满了，那么程序会陷入死循环，那么我们就需要进行扩容

在这里插入图片描述

负载因子越高，冲突率越高，效率就越低
负载因子越低，冲突率越低，效率就越高，但空间利用率就越低

这种关联式容器的扩容不仅仅是拷贝下来，还得考虑数据与模的大小的关系

所以，先进行扩容，再将原有的值重新映射

第一步优化：

template<class K,class V>
struct HashData
{pair<K, V> _kv;State _state=Empty;
};template<class K, class V>
class HashTable
{
public:HashTable(){_tables.resize(10);}bool Insert(const pair<K,V>& kv){if (_n * 10 / _tables.size() >= 7){}size_t hashi = kv.first % _tables.size();while (_tables[hashi]._state == Exist){++hashi;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._state = Exist;++_n;}
private:vector<HashData<K, V>> _tables;size_t _n=0;//有效数据个数
};

增加构造函数与缺省值，对于内置类型_state，我们设置它初始状态为Empty

bool Insert(const pair<K,V>& kv)
{if (Find(kv.first)) return false;if (_n * 10 / _tables.size() >= 7){/*size_t newsize = _tables.size() * 2;vector<HashData<K, V>> newtables(newsize);*///旧表重新计算负载到新表size_t newsize = _tables.size() * 2;HashTable<K, V> newHashTable;newHashTable._tables.resize(newsize);for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]._state == Exist){newHashTable.Insert(_tables[i]._kv);}}*this = std::move(newHashTable);//_tables.swap(newHashTable._tables);}size_t hashi = kv.first % _tables.size();while (_tables[hashi]._state == Exist){++hashi;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._state = Exist;++_n;return true;
}

这里我们直接在函数里面构建一个新的哈希表，再if里面调用insert永远不会再进入第一个if判断，因为我这里的空间大小已经开好了，后面直接调用映射的部分，最后更新原哈希表即可

HashData<K, V>* Find(const K&key)
{size_t hashi = key % _tables.size();while (_tables[hashi]._state != Empty){if (_tables[hashi]._state==Exist&&_tables[hashi]._kv.first == key) return &_tables[hashi];++hashi;hashi %= _tables.size();}return nullptr;
}
bool Erase(const K& key)
{HashData<K, V>* ret = Find(key);if (ret == nullptr) return false;else{ret->_state = Delete;--_n;return true;}
}

这两个函数搭配使用，我第一个返回地址，第二个根据是否能找到的索引来进行修改，非常方便

在这里插入图片描述
线性探测优点：实现非常简单，
线性探测缺点：一旦发生哈希冲突，所有的冲突连在一起，容易产生数据“堆积”，即：不同关键码占据了可利用的空位置，使得寻找某关键码的位置需要许多次比较，导致搜索效率降低

这里还有一个问题：如果我插入的是K是string之类的，我该如何取模呢？

template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};struct StringHashFunc
{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash += e;}return hash;}
};template<class K, class V,class Hash=HashFunc<K>>
class HashTable
{——————————

默认的仿函数进行对数据的转换，比如负数，浮点型直接强转为size_t，对于string类我们特化一个仿函数，返回它的ascll值之和

Hash hs;
size_t hashi = hs(kv.first) % _tables.size();
二次探测

线性探测的缺陷是产生冲突的数据堆积在一块，这与其找下一个空位置有关系，因为找空位置的方式就是挨着往后逐个去找，因此二次探测为了避免该问题，找下一个空位置的方法为： H i H_i Hi​ = ( H 0 H_0 H0​ + i 2 i^2 i2 )% m, 或者： H i H_i Hi​ = ( H 0 H_0 H0​ - i 2 i^2 i2 )% m。其中：i = 1,2,3…， H 0 H_0 H0​是通过散列函数Hash(x)对元素的关键码 key 进行计算得到的位置，m是表的大小

2.3.2开散列

开散列法又叫链地址法(开链法)，首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个子集合称为一个桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中

在这里插入图片描述

开散列中每个桶中放的都是发生哈希冲突的元素

代码：

template<class K, class V>
struct HashNode
{pair<K, V> _kv;HashNode<K, V>* _next;
};template<class K, class V>
class HashTable
{
public:typedef HashNode<K, V> Node;HashTable()
{_tables.resize(10, nullptr);
}
private:vector<Node*> _tables;size_t _n=0;
};

插入函数依旧复用，这里用链表的头插

bool Insert(const pair<K, V>& kv)
{if (_n == _tables.size()){HashTable<K, V> newHT;newHT._tables.resize(_tables.size() * 2);for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur) {newHT.Insert(cur->kv);cur = cur->_next;}}_tables.swap(newHT._tables);}size_t hashi = kv.first & _tables.size();Node* newnode = new Node(kv);//头插newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return true;
}

这里有一个问题，我如果重新插入，那么原来的节点就需要手动去释放，非常麻烦，我们这里可以直接复用上面的节点

bool Insert(const pair<K, V>& kv)
{if (_n == _tables.size()){vector<Node*> newTables(_tables.size()*2,nullptr);for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){//头插到新表的位置Node* next = cur->_next;size_t hashi = cur->_kv.first % newTables.size();cur->_next = newTables[hashi];newTables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newTables);}size_t hashi = kv.first & _tables.size();Node* newnode = new Node(kv);//头插newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return true;
}

取出一个节点放到新的表中，每次取完一组后置空，最后交换

bool Erase(const K& key)
{size_t hashi = key % _tables.size();Node* cur = _tables[hashi];Node* pre = nullptr;while (cur){if (cur->_kv.first == key){if (pre == nullptr){_tables[hashi]=cur->_next；}else{pre->_next = cur->_next;}delete cur;}else{prev = cur;cur = cur->_next;}}
}

补充仿函数：

template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};struct StringHashFunc
{size_t operator()(const string& key){size_t ch = 0;for (auto e : key){ch += e ;}return ch;}
};

3. 封装


template<class T>
struct HashNode
{T _data;HashNode<T>* _next;HashNode(const T& data):_data(data),_next(nullptr){}
};template<class K, class T,class Hash =HashFunc<K>>
class HashTable
{
public:typedef HashNode<T> Node;

Node设置一个模版参数T，对于unordered_set 传入K，对于unordered_map 传入pair<K,V>，跟之前set，map封装类似,再增加一个KeyofT的仿函数

template<class K,class V> 
class Unordered_map
{
public:struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};
private:HashTable<K, pair<K, V>,MapKeyOfT> _ht;
};

template<class K>
class Unordered_set
{
public:struct SetKeyOfT{const K& operator()(const K& key){return key;}};
private:HashTable<K, K,SetKeyOfT> _ht;
};

迭代器封装

template<class K,class T,class KeyofT,class Hash>
class _HTIterator
{typedef<HashNode<T>> Node;Node* _node;HashTable<K, V, KeyofT, Hash>* _pht;operator++(){if (_node->next){_node = node->next;}else{}}
};

库里面直接将哈希表的地址穿过来以便迭代器来遍历

在这里插入图片描述

在这里插入图片描述
找到第一个节点，返回iterator，构造函数返回当前节点指针和哈希表，this就派上用场了

Self& operator++()
{if (_node->next){//当前桶没走完_node = node->next;}else{//找不为空的桶KeyofT kot;Hash hs;size_t i = hs(kot(_node->_data)) % _pht->_tables.size();//仿函数叠加++i;for (; i < _pht->_tables.size(); i++){if (_pht->_tables[i]) break;}if (i == _pht->_tables.size()) _node = nullptr;else _node = _pht->_tables[i];}return *this;
}

完整代码：

#pragma once
#include<iostream>
#include<vector>
using namespace std;template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};struct StringHashFunc
{size_t operator()(const string& key){size_t ch = 0;for (auto e : key){ch += e ;}return ch;}
};template<class T>
struct HashNode
{T _data;HashNode<T>* _next;HashNode(const T& data):_data(data),_next(nullptr){}
};
template<class K, class T, class KeyofT, class Hash>//前置声明
class HashTable;template<class K,class T,class KeyofT,class Hash>
class _HTIterator
{
public:typedef HashNode<T> Node;typedef _HTIterator<K, T, KeyofT, Hash> Self;Node* _node;HashTable<K, T, KeyofT, Hash>* _pht;_HTIterator(Node* node, HashTable<K, T, KeyofT, Hash>* pht):_node(node),_pht(pht){}Self& operator++(){if (_node->_next){//当前桶没走完_node = _node->_next;}else{//找不为空的桶KeyofT kot;Hash hs;size_t i = hs(kot(_node->_data)) % _pht->_tables.size();//仿函数叠加++i;for (; i < _pht->_tables.size(); i++){if (_pht->_tables[i]) break;}if (i == _pht->_tables.size()) _node = nullptr;else _node = _pht->_tables[i];}return *this;}bool operator!=(const Self& s){return _node != s._node;}T& operator*(){return _node->_data;}
};
template<class K, class T, class KeyofT, class Hash = HashFunc<K>>
class HashTable
{
public:template<class K, class T, class KeyofT, class Hash>friend class _HTIterator;typedef _HTIterator<K, T, KeyofT, Hash> iterator;iterator begin(){for (size_t i = 0; i < _tables.size();i++){Node* cur = _tables[i];if (cur){return iterator(cur, this);}}}iterator end(){return iterator(nullptr, this);}typedef HashNode<T> Node;HashTable(){_tables.resize(10, nullptr);}~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}//bool Insert(const pair<K, V>& kv)//{//	if (_n == _tables.size())//	{//		HashTable<K, V> newHT;//		newHT._tables.resize(_tables.size() * 2);//		for (size_t i = 0; i < _tables.size(); i++)//		{//			Node* cur = _tables[i];//			while (cur) //			{//				newHT.Insert(cur->kv);//				cur = cur->_next;//			}//		}//		_tables.swap(newHT._tables);//	}//	size_t hashi = kv.first & _tables.size();//	Node* newnode = new Node(kv);//	//头插//	newnode->_next = _tables[hashi];//	_tables[hashi] = newnode;//	++_n;//	return true;//}bool Insert(const T& data){HashFunc<K> hs;KeyofT kot;if (Find(kot(data))) return false;if (_n == _tables.size()){vector<Node*> newTables(_tables.size()*2,nullptr);for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){//头插到新表的位置Node* next = cur->_next;size_t hashi = hs(kot(cur->_data)) % newTables.size();cur->_next = newTables[hashi];newTables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newTables);}size_t hashi = hs(kot(data)) % _tables.size();Node* newnode = new Node(data);//头插newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return true;}bool Erase(const K& key){KeyofT kot;                  // KeyofT 实例化HashFunc<K> hs;size_t hashi = hs(key) % _tables.size();Node* cur = _tables[hashi];Node* pre = nullptr;while (cur){// 使用 kot(cur->_data) 来获取当前节点的数据的键if (kot(cur->_data) == key){if (pre == nullptr){_tables[hashi] = cur->_next;}else{pre->_next = cur->_next;}delete cur;--_n;return true;}else{pre = cur;cur = cur->_next;}}return false;}Node* Find(const K& key){KeyofT kot;HashFunc<K> hs;size_t hashi = hs(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key) return cur;cur = cur->_next;}return nullptr;}
private:vector<Node*> _tables;size_t _n=0;
};

#pragma once
#include"HashBucket.h"template<class K>
class Unordered_set
{
public:struct SetKeyOfT{const K& operator()(const K& key){return key;}};typedef typename HashTable<K, K, SetKeyOfT>::iterator iterator;iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}bool insert(const K& key){return _ht.Insert(key);}
private:HashTable<K, K,SetKeyOfT> _ht;
};void testset()
{Unordered_set<int> s;s.insert(31);s.insert(11);s.insert(5);s.insert(15);s.insert(20);Unordered_set<int>::iterator it = s.begin();while (it != s.end()){cout << *it << " ";++it;}
}

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

@Query（org.springframework.data.jpa.repository.Query）

@Query（org.springframework.data.jpa.repository.Query）

文章目录 1. findPAProductByAdminId 方法作用&#xff1a;解释&#xff1a; 2. findPaginatedPAProductByAdminId 方法作用&#xff1a;解释&#xff1a; 总结&#xff1a; package com.productQualification.resource.repository.productAuthentication;import com.productQu…
阅读更多...
[Collection与数据结构] PriorityQueue与堆

[Collection与数据结构] PriorityQueue与堆

1. 优先级队列 1.1 概念 前面介绍过队列&#xff0c;队列是一种先进先出(FIFO)的数据结构&#xff0c;但有些情况下&#xff0c;操作的数据可能带有优先级&#xff0c;一般出队列时&#xff0c;可能需要优先级高的元素先出队列&#xff0c;该中场景下&#xff0c;使用队列显然…
阅读更多...
STM32网络通讯之CubeMX实现LWIP项目设计（十五）

STM32网络通讯之CubeMX实现LWIP项目设计（十五）

STM32F407 系列文章 - ETH-LWIP-CubeMX&#xff08;十五&#xff09; 目录 前言 一、软件设计 二、CubeMX实现 1.配置前准备 2.CubeMX配置 1.ETH模块配置 2.时钟模块配置 3.中断模块配置 4.RCC及SYS配置 5.LWIP模块配置 3.生成代码 1.main文件 2.用户层源文件 3.…
阅读更多...
【React】静态组件动态组件

【React】静态组件动态组件

目录 静态组件动态组件创建一个构造函数(类)使用 class 实现组件**使用 function 实现类组件** 静态组件 函数组件是静态组件&#xff1a; 组件第一次渲染完毕后&#xff0c;无法基于内部的某些操作让组件更新「无法实现自更新」&#xff1b;但是&#xff0c;如果调用它的父组…
阅读更多...
我的世界-与门、或门、非门等基本门电路实现

我的世界-与门、或门、非门等基本门电路实现

一、红石比较器 (1) 红石比较器结构 红石比较器有前端单火把、后端双火把以及两个侧端 其中后端和侧端是输入信号,前端是输出信号 (2) 红石比较器的两种模式 比较模式 前端火把未点亮时处于比较模式 侧端>后端 → 0 当任一侧端强度大于后端强度时,输出…
阅读更多...
持续集成 01|Gitee介绍、Pycharm使用Gitee

持续集成 01|Gitee介绍、Pycharm使用Gitee

目录 一、理论 二、 git的简介与安装 三、Gitee 1、注册网易163邮箱 2、注册Gitee账号 3、git和gitee管理代码工作原理 三、PyCharm安装配置Gitee 四、Pycharm使用Gitee插件的五种场景 1、将 Gitee的新仓库 Checkout&#xff08;检出&#xff09;到 Pycharm中 2、推送…
阅读更多...
【Qt】03－页面切换

【Qt】03－页面切换

前言一、按键实现界面切换1.1 创建新的类文件1.1.1 创建1.1.2 细节选择 1.2 代码以及需要注意的点mywidget.cppsecondwidget.cppmywidget.hsecondwidget.h 1.3 结果展示 二、signal关键字2.1 代码以及解释mywidget.cppsecondwidget.cppmywidget.hsecondwidget.h解释 2.2 现象 三…
阅读更多...
软件授权管理中的软件激活向导示例

软件授权管理中的软件激活向导示例

软件激活向导示例 在软件许可中&#xff0c;提供许可应该是简单和安全的。这适用于想要在中央许可证服务器上创建新许可证的软件开发人员&#xff0c;也适用于需要在其设备上获得许可证的最终用户。如果所讨论的系统有互联网连接&#xff0c;或是暂时的连接&#xff0c;就可以…
阅读更多...
02JavaWeb——JavaScript-Vue（项目实战）

02JavaWeb——JavaScript-Vue（项目实战）

一、JavaScript html完成了架子&#xff0c;css做了美化&#xff0c;但是网页是死的&#xff0c;我们需要给他注入灵魂&#xff0c;所以接下来我们需要学习 JavaScript&#xff0c;这门语言会让我们的页面能够和用户进行交互。 1.1 介绍 通过JS/js效果演示提供资料进行效果演…
阅读更多...
【java】java入门

【java】java入门

盘符名称冒号---------盘符切换 dir---------------查看当前路径下的内容 cd目录--------进入单级目录 cd..----------回退到上一级目录 cd \----------回退到盘符目录 cls----------清屏 exit 为什么要配环境变量&#xff1f; 在任意的目录下都可以打开指定的软件。把软件的路…
阅读更多...
利用爬虫获取某学习软件的考试题库（带源码）

利用爬虫获取某学习软件的考试题库（带源码）

首先要重新进行账号的登陆用来获取cookie 按下F12在控制台输入&#xff1a; // 获取当前页面的 cookies var cookies document.cookie.split(";");// 创建一个数组来存储 cookies 对象 var cookieArray [];// 遍历每个 cookie 并将其转换为对象 cookies.forEach(f…
阅读更多...
【C++篇】红黑树的实现

【C++篇】红黑树的实现

目录 前言&#xff1a; 一&#xff0c;红黑树的概念 1.1&#xff0c;红黑树的规则 1.2&#xff0c;红黑树的最长路径 1.3&#xff0c;红黑树的效率分析 二&#xff0c;红黑树的实现 2.1&#xff0c;红黑树的结构 2.2&#xff0c;红黑树的插入 2.2.1&#xff0c;大致过程…
阅读更多...
Autodl转发端口，在本地机器上运行Autodl服务器中的ipynb文件

Autodl转发端口，在本地机器上运行Autodl服务器中的ipynb文件

通过 SSH 隧道将远程端口转发到本地机器 输入服务器示例的SSH指令和密码&#xff0c;将远程的6006端口代理到本地 在服务器终端&#xff0c;激活conda虚拟环境 conda activate posecnnexport PYOPENGL_PLATFORMegljupyter notebook --no-browser --port6006 --allow-root从…
阅读更多...
镭速大文件传输视频文件预览实现原理

镭速大文件传输视频文件预览实现原理

镭速可以支持视频预览&#xff0c;在测试过程中需要大量不同格式的视频&#xff0c;如果直接去找各种格式的视频不太现实&#xff0c;所以就会用到一个视频格式转换的工具ffmpeg&#xff0c;本文将介绍ffmpeg的基本使用方法。FFmpeg 是一个免费开源的音视频处理工具&#xff0c…
阅读更多...
达梦8-DMSQL程序设计学习笔记1-DMSQL程序简介

达梦8-DMSQL程序设计学习笔记1-DMSQL程序简介

1、DMSQL程序简介 DMSQL程序是达梦数据库对标准SQL语言的扩展&#xff0c;是一种过程化SQL语言。在DMSQL程序中&#xff0c;包括一整套数据类型、条件结构、循环结构和异常处理结构等&#xff0c;DMSQL程序中可以执行SQL语句&#xff0c;SQL语句中也可以使用DMSQL函数。 DMSQ…
阅读更多...
C# 获取PDF文档中的字体信息（字体名、大小、颜色、样式等

C# 获取PDF文档中的字体信息（字体名、大小、颜色、样式等

在设计和出版行业中&#xff0c;字体的选择和使用对最终作品的质量有着重要影响。然而&#xff0c;有时我们可能会遇到包含未知字体的PDF文件&#xff0c;这使得我们无法准确地复制或修改文档。获取PDF中的字体信息可以解决这个问题&#xff0c;让我们能够更好地处理这些文件。…
阅读更多...
git操作（Windows中GitHub）

git操作（Windows中GitHub）

使用git控制GitHub中的仓库版本&#xff0c;并在Windows桌面中创建与修改代码&#xff0c;与GitHub仓库进行同步。 创建自己的GitHub仓库 创建一个gen_code实验性仓库用来学习和验证git在Windows下的使用方法&#xff1a; gen_code仓库 注意&#xff0c;创建仓库时不要设置…
阅读更多...
thinkphp6 + redis实现大数据导出excel超时或内存溢出问题解决方案

thinkphp6 + redis实现大数据导出excel超时或内存溢出问题解决方案

redis下载安装&#xff08;window版本&#xff09; 参考地址&#xff1a;https://blog.csdn.net/Ci1693840306/article/details/144214215 php安装redis扩展 参考链接&#xff1a;https://blog.csdn.net/jianchenn/article/details/106144313 解决思路&#xff1a;&#xff0…
阅读更多...
设计模式-工厂模式/抽象工厂模式

设计模式-工厂模式/抽象工厂模式

工厂模式 定义 定义一个创建对象的接口&#xff0c;让子类决定实列化哪一个类&#xff0c;工厂模式使一个类的实例化延迟到其子类&#xff1b; 工厂方法模式是简单工厂模式的延伸。在工厂方法模式中&#xff0c;核心工厂类不在负责产品的创建&#xff0c;而是将具体的创建工作…
阅读更多...
学习threejs，使用OrbitControls相机控制器

学习threejs，使用OrbitControls相机控制器

&#x1f468;‍⚕️ 主页&#xff1a; gis分享者 &#x1f468;‍⚕️ 感谢各位大佬 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! &#x1f468;‍⚕️ 收录于专栏&#xff1a;threejs gis工程师 文章目录 一、&#x1f340;前言1.1 ☘️THREE.OrbitControls 相机控…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023