C++哈希(个人笔记)

C++哈希

    • 1.unordered_mapd
      • 1.1unordered_map的构造函数
      • 1.2unorder_map的容量
      • 1.3unordered_map的迭代器
      • 1.4unordered_map的元素访问
      • 1.5unorder_map的查找
      • 1.6unordered_map的修改操作
      • 1.7unordered_map的桶操作
    • 2.unordered_set
    • 3.unordered_set和unordered_set的笔试题
    • 4.哈希
      • 4.1哈希概念
      • 4.2哈希冲突
      • 4.3哈希函数
      • 4.4哈希冲突解决
        • 4.4.1闭散列
          • 4.4.1.1线性探测的实现
        • 4.4.2开散列
          • 4.4.2.1开散列的实现
    • 4.unordered_map和unordered_set模拟实现
      • 4.1哈希表的改造
      • 4.2unordered_set模拟实现
      • 4.3unordered_map模拟实现
    • 5.位图
      • 5.1位图的实现
      • 5.2布隆过滤器
        • 5.2.1布隆过滤器的实现


1.unordered_mapd

C++unorder_map官方文档

1.1unordered_map的构造函数

函数声明功能介绍
unordered_map构造不同格式的unordered_map对象

1.2unorder_map的容量

函数声明功能介绍
bool empty() const检测unordered_map是否为空
size_t size() const获取unordered_map的有效元素个数

1.3unordered_map的迭代器

函数声明功能介绍
begin返回unordered_map第一个元素的迭代器
end返回unordered_map最后一个元素下一个位置的迭代器
cbegin返回unordered_map第一个元素的const迭代器
cend返回unordered_map最后一个元素下一个位置的const迭代器

1.4unordered_map的元素访问

函数声明功能介绍
operator[]返回与key对应的value,没有则返回一个默认值

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

1.5unorder_map的查找

函数声明功能介绍
iterator find(const K& key)返回key在哈希桶中的位置
size_t count(const K& key)返回哈希桶中关键码为key的键值对的个数

注意:unordered_map中key是不能重复的,因此count函数的返回值最大为1

1.6unordered_map的修改操作

函数声明功能介绍
insert向容器中插入键值对
erase删除容器中的键值对
void clear()清空容器中有效元素个数
void swap(unorder map&)交换两个容器中的元素

1.7unordered_map的桶操作

函数声明功能介绍
size_t bucket count()const返回哈希桶中桶的总个数
size_t bucket size(size_t n)const返回n号桶中有效元素的总个数
size_t bucket(const K& key)返回元素key所在的桶号

2.unordered_set

C++unordered_set官方文档
这里不在一 一列举

3.unordered_set和unordered_set的笔试题

在长度 2N 的数组中找出重复 N 次的元素
在这里插入图片描述

class Solution {
public:int repeatedNTimes(vector<int>& nums){unordered_map<int, int> found;for (int num : nums){found[num]++;}for (auto it = found.begin(); it != found.end(); ++it){if (it->second == nums.size() / 2){return it->first;}}return -1;}
};

两个数组的交集
在这里插入图片描述

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());auto it1=s1.begin();auto it2=s2.begin();vector<int> v;while(it1!=s1.end()&&it2!=s2.end()){if(*it1<*it2){++it1;}else if(*it1>*it2){++it2;}else{v.push_back(*it1);++it1;++it2;}}return v;}
};

两个数组的交集 II
在这里插入图片描述

class Solution {
public:vector<int> intersect(vector<int>& nums1, vector<int>& nums2){multiset<int> s1(nums1.begin(),nums1.end());multiset<int> s2(nums2.begin(),nums2.end());auto it1=s1.begin();auto it2=s2.begin();vector<int> v;while(it1!=s1.end()&&it2!=s2.end()){if(*it1<*it2){it1++;}else if(*it1>*it2){it2++;}else{v.push_back(*it1);it1++;it2++;}}return v;}
};

存在重复元素
在这里插入图片描述

class Solution {
public:bool containsDuplicate(vector<int>& nums){unordered_map<int,int> mp;for(int num:nums){mp[num]++;}auto it=mp.begin();while(it!=mp.end()){if(it->second>=2){return true;}++it;}return false;}
};

两句话中的不常见单词
在这里插入图片描述

class Solution {
public:vector<string> uncommonFromSentences(string s1, string s2){vector<string> v;unordered_map<string,int> mp;stringstream ss1(s1);string word;while(ss1>>word){mp[word]++;}stringstream ss2(s2);while(ss2>>word){mp[word]++;}for(auto& w:mp){if(w.second==1){v.push_back(w.first);}}return v;}
};

4.哈希

4.1哈希概念

通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一 一映射的关系,在查找时通过该函数可以很快找到该元素。

1.插入元素
根据待插入元素的关键码,以此函数计算出该元素的存储位置并按此位置进行存放

2.搜索元素
对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按此位置取元素比较,若关键码相等,则找到了

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

4.2哈希冲突

不同关键字通过相同哈希哈数计算出相同的哈希地址,该种现象称为哈希冲突或哈希碰撞。

4.3哈希函数

哈希函数设计原则:

  1. 1.哈希函数的定义域必须包括需要存储的全部关键码,而如果散列表允许有m个地址时,其值域必须在0到m-1之间

  2. 哈希函数计算出来的地址能均匀分布在整个空间中

  3. 哈希函数应该比较简单
    常见的哈希函数

  4. 直接定址法–(常用)
    取关键字的某个线性函数为散列地址:Hash(Key)= A*Key + B
    优点:简单、均匀
    缺点:需要事先知道关键字的分布情况
    使用场景:适合查找比较小且连续的情况

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

4.4哈希冲突解决

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

4.4.1闭散列

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

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

1.插入

  1. 通过哈希函数获取待插入元素在哈希表中的位置
  2. 如果该位置中没有元素则直接插入新元素,如果该位置中有元素发生哈希冲突, 使用线性探测找到下一个空位置,插入新元素
    在这里插入图片描述
    2.删除
    采用闭散列处理哈希冲突时,不能物理删除哈希表中已有的元素,若直接删除元素会影响其他元素的搜索。比如删除元素4,如果直接删除掉,44查找起来可能会受影响。因此线性探测采用标记的伪删除法来删除一个元素。(也就是给位置标记状态)
// 哈希表每个空间给个标记
// EMPTY此位置空, EXIST此位置已经有元素, DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};
4.4.1.1线性探测的实现
enum Status
{EMPTY,EXIST,DELETE
};template<class K,class V>
struct HashData
{pair<K, V> _kv;Status _s;          //状态
};//HashFunc<int>
template<class K>
struct HashFunc
{size_t operator()(const K& Key){return (size_t)Key;}
};//HashFunc<string>
template<>
struct HashFunc<string>
{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash *= 31;hash += e;}cout << key << ":" << hash << endl;return hash;}
};template<class K,class V,class Hash=HashFunc<K>>
class HashTable
{
public:HashTable(){_tables.resize(10);}bool Insert(const pair<K, V>& kv){if (Find(kv.first)){return false;}//负载因子0.7就扩容if (_n * 10 / _tables.size() == 7){size_t newSize = _tables.size() * 2;HashTable<K, V> newHT;newHT._tables.resize(newSize);for (size_t i = 0;i < _tables.size();i++){if (_tables[i]._s == EXIST){newHT.Insert(_tables[i]._kv);}}_tables.swap(newHT._tables);}Hash hf;size_t hashi = hf(kv.first) % _tables.size();while (_tables[hashi]._s == EXIST){hashi++;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._s = EXIST;++_n;return true;}HashData<K, V>* Find(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();while (_tables[hashi]._s != EMPTY){if (_tables[hashi]._s == 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){ret->_s = DELETE;--_n;return true;}else{return false;}}void Print(){for (size_t i = 0;i < _tables.size();i++){if (_tables[i]._s == EXIST){cout << "[" << i << "]->" << _tables[i]._kv.first << ":" << _tables[i]._kv.second << endl;}else if (_tables[i]._s == EMPTY){printf("[%d]->\n", i);}else{printf("[%d]->D\n", i);}}cout << endl;}private:vector<HashData<K,V>> _tables;size_t _n = 0;//存储的关键字的个数
};

线性探测优点:实现非常简单

线性探测缺点:一旦发生哈希冲突,所有的冲突连在一起,容易产生数据“堆积”,即:不同
关键码占据了可利用的空位置,使得寻找某关键码的位置需要许多次比较,导致搜索效率降
低。

4.4.2开散列

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

4.4.2.1开散列的实现
//HashFunc<int>
template<class K>
struct HashFunc
{size_t operator()(const K& Key){return (size_t)Key;}
};//HashFunc<string>
template<>
struct HashFunc<string>
{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash *= 31;hash += e;}cout << key << ":" << hash << endl;return hash;}
};template<class K, class V>
struct HashNode
{HashNode* _next;pair<K, V> _kv;HashNode(const pair<K, V>& kv):_kv(kv), _next(nullptr){}
};template<class K, class V,class Hash=HashFunc<K>>
class HashTable
{typedef HashNode<K, V> Node;
public:HashTable(){_tables.resize(10);}~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 (Find(kv.first))return false;Hash hf;// 负载因子最大到1if (_n == _tables.size()){vector<Node*> newTables;newTables.resize(_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 = hf(cur->_kv.first) % newTables.size();cur->_next = newTables[hashi];//标记newTables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newTables);}size_t hashi = hf(kv.first) % _tables.size();Node* newnode = new Node(kv);// 头插newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return true;}Node* Find(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){return cur;}cur = cur->_next;}return nullptr;}bool Erase(const K& key){Hash hf;size_t hashi = hf(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true;}prev = cur;cur = cur->_next;}return false;}void Some(){size_t bucketSize = 0;size_t maxBucketLen = 0;size_t sum = 0;double averageBucketLen = 0;for (size_t i = 0;i < _tables.size();i++){Node* cur = _tables[i];if (cur){++bucketSize;}size_t bucketLen = 0;while (cur){++bucketLen;cur = cur->_next;}sum += bucketLen;if (bucketLen > maxBucketLen){maxBucketLen = bucketLen;}}printf("all bucketSize:%d\n", _tables.size());printf("bucketSize:%d\n", bucketSize);printf("maxBucketLen:%d\n", maxBucketLen);printf("averageBucketLen:%lf\n\n", averageBucketLen);}private:vector<Node*> _tables;size_t _n = 0;
};

4.unordered_map和unordered_set模拟实现

4.1哈希表的改造

//HashFunc<int>
template<class K>
struct HashFunc
{size_t operator()(const K& Key){return (size_t)Key;}
};//HashFunc<string>
template<>
struct HashFunc<string>
{size_t operator()(const string& key){size_t hash = 0;for (auto e : key){hash *= 31;hash += e;}cout << key << ":" << hash << endl;return hash;}
};
namespace hash_bucket
{template<class T>struct HashNode{HashNode* _next;T _data;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 Ref,class Ptr,class KeyOfT,class Hash>struct __HTIterator{typedef HashNode<T> Node;typedef __HTIterator<K, T, Ref, Ptr, KeyOfT, Hash> Self;Node* _node;const HashTable<K, T, KeyOfT, Hash>* _pht;size_t _hashi;__HTIterator(Node* node,HashTable<K,T,KeyOfT,Hash>* pht,size_t hashi):_node(node),_pht(pht),_hashi(hashi){}__HTIterator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht, size_t hashi):_node(node), _pht(pht), _hashi(hashi){}Self& operator++(){if (_node->_next){_node = _node->_next;}else{++_hashi;while (_hashi < _pht->_tables.size()){if (_pht->_tables[_hashi]){_node = _pht->_tables[_hashi];break;}++_hashi;}if (_hashi == _pht->_tables.size()){_node = nullptr;}}return *this;}Ref operator*(){return _node->_data;}Ptr operator->(){return &(_node->_data);}bool operator!=(const Self& s){return _node != s._node;}};//unordered_set->HashTable<K,K>//unordered_map->HashTable<K,pair<K,V>>template<class K, class T,class KeyOfT,class Hash>class HashTable{typedef HashNode<T> Node;template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>friend struct __HTIterator;public:typedef __HTIterator<K, T, T&, T*, KeyOfT, Hash> iterator;typedef __HTIterator<K, T, const T&, const T*, KeyOfT, Hash> const_iterator;iterator begin(){for (size_t i = 0;i < _tables.size();i++){if (_tables[i]){return iterator(_tables[i], this, i);}}return end();}iterator end(){return iterator(nullptr, this, -1);}const_iterator begin() const{for (size_t i = 0;i < _tables.size();i++){if (_tables[i]){return const_iterator(_tables[i], this, i);}}return end();}const_iterator end() const{return const_iterator(nullptr, this, -1);}HashTable(){_tables.resize(10);}~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;}}pair<iterator,bool> Insert(const T& data){Hash hf;KeyOfT kot;iterator it = Find(kot(data));if (it != end()){return make_pair(it, false);}// 负载因子最大到1if (_n == _tables.size()){vector<Node*> newTables;newTables.resize(_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 = hf(kot(data)) % newTables.size();cur->_next = newTables[hashi];//标记newTables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newTables);}size_t hashi = hf(kot(data)) % _tables.size();Node* newnode = new Node(data);// 头插newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_n;return make_pair(iterator(newnode,this,hashi),true);}iterator Find(const K& key){Hash hf;KeyOfT kot;size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){return iterator(cur,this,hashi);}cur = cur->_next;}return end();}bool Erase(const K& key){Hash hf;KeyOfT kot;size_t hashi = hf(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true;}prev = cur;cur = cur->_next;}return false;}void Some(){size_t bucketSize = 0;size_t maxBucketLen = 0;size_t sum = 0;double averageBucketLen = 0;for (size_t i = 0;i < _tables.size();i++){Node* cur = _tables[i];if (cur){++bucketSize;}size_t bucketLen = 0;while (cur){++bucketLen;cur = cur->_next;}sum += bucketLen;if (bucketLen > maxBucketLen){maxBucketLen = bucketLen;}}averageBucketLen = (double)sum / (double)bucketSize;printf("all bucketSize:%d\n", _tables.size());printf("bucketSize:%d\n", bucketSize);printf("maxBucketLen:%d\n", maxBucketLen);printf("averageBucketLen:%lf\n\n", averageBucketLen);}private:vector<Node*> _tables;size_t _n = 0;};
}

4.2unordered_set模拟实现

#pragma once
#include"HashTable.h"namespace ljh
{template<class K, class Hash = HashFunc<K>>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename hash_bucket::HashTable<K, K, SetKeyOfT, Hash>::const_iterator iterator;typedef typename hash_bucket::HashTable<K, K, SetKeyOfT, Hash>::const_iterator const_iterator;/*iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}*/const_iterator begin() const{return _ht.begin();}const_iterator end() const{return _ht.end();}pair<const_iterator, bool> insert(const K& key){auto ret = _ht.Insert(key);return pair<const_iterator, bool>(const_iterator(ret.first._node, ret.first._pht, ret.first._hashi), ret.second);}iterator find(const K& key){return _ht.Find(key);}bool erase(const K& key){return _ht.Erase(key);}private:hash_bucket::HashTable<K, K, SetKeyOfT, Hash> _ht;};
}

4.3unordered_map模拟实现

#pragma once
#include"HashTable.h"
namespace ljh
{template<class K,class V,class Hash=HashFunc<K>>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::iterator iterator;iterator begin(){return _ht.begin();}iterator end(){return _ht.end();}pair<iterator, bool> insert(const pair<K, V>& kv){return _ht.Insert(kv);}V& operator[](const K& key){pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));return ret.first->second;}const V& operator[](const K& key) const{pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));return ret.first->second;}iterator find(const K& key){return _ht.Find(key);}bool erase(const K& key){return _ht.Erase(key);}private:hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;};
}

5.位图

给40亿个不重复的无符号整数,没排过序。给一个无符号整数,如何快速判断一个数是否在这40亿个数中。
解决方案:
1:暴力遍历:时间复杂度O(N)
2.快排(O(NlogN))+二分查找(logN)
3.位图
数据是否在给定的整形数据中,结果是在或者不在,刚好是两种状态,可以使用一个二进制比特位来代表数据是否存在,如果二进制比特位为1,代表存在,为0代表不存在。

5.1位图的实现

//N为需要多少比特位
template<size_t N>
class bitset
{
public:bitset(){_bits.resize(N / 32 + 1);}void set(size_t x){size_t i = x / 32;size_t j = x % 32;_bits[i] |= (1 << j);}void reset(size_t x){size_t i = x / 32;size_t j = x % 32;_bits[i] &= ~(1 << j);}bool test(size_t x){size_t i = x / 32;size_t j = x % 32;return _bits[i] & (1 << j);}private:vector<int> _bits;
};template<size_t N>
class twobitset
{
public:void set(size_t x){//00->01//01->10//10->11//11->不变if (_bs1.test(x) == false && _bs2.test(x) == false){_bs2.set(x);}else if (_bs1.test(x) == false && _bs2.test(x) == true){_bs1.set(x);_bs2.reset(x);}else if (_bs1.test(x) == true && _bs2.test(x) == false){_bs2.set(x);}}void Print(){for (size_t i = 0;i < N;i++){if (_bs1.test(i) == false && _bs2.test(i) == true){cout << "1->" << i << endl;}else if (_bs1.test(i) == true && _bs2.test(i) == false){cout << "2->" << i << endl;}}cout << endl;}private:bitset<N> _bs1;bitset<N> _bs2;
};

5.2布隆过滤器

具体实现思想:用多个哈希函数,将一个数据映射到位图结构中
作用:某样东西一定不存在或者可能存在
在这里插入图片描述
在这里插入图片描述

5.2.1布隆过滤器的实现
#include<string>
#include<iostream>
#include<vector>
using namespace std;
#include"bitset.h"
struct BKDRHash
{size_t operator()(const string& key){// BKDRsize_t hash = 0;for (auto e : key){hash *= 31;hash += e;}return hash;}
};struct APHash
{size_t operator()(const string& key){size_t hash = 0;for (size_t i = 0; i < key.size(); i++){char ch = key[i];if ((i & 1) == 0){hash ^= ((hash << 7) ^ ch ^ (hash >> 3));}else{hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));}}return hash;}
};struct DJBHash
{size_t operator()(const string& key){size_t hash = 5381;for (auto ch : key){hash += (hash << 5) + ch;}return hash;}
};template<size_t N,class K = string,class HashFunc1 = BKDRHash,class HashFunc2 = APHash,class HashFunc3 = DJBHash>
class BloomFilter
{
public:void Set(const K& key){size_t hash1 = HashFunc1()(key) % N;size_t hash2 = HashFunc2()(key) % N;size_t hash3 = HashFunc3()(key) % N;_bs.set(hash1);_bs.set(hash2);_bs.set(hash3);}//void Reset(const K& key);一般不支持删除bool Test(const K& key){//判断不存在是准确的,其他的都是存在偏差的size_t hash1 = HashFunc1()(key) % N;if (_bs.test(hash1) == false){return false;}size_t hash2 = HashFunc2()(key) % N;if (_bs.test(hash2) == false){return false;}size_t hash3 = HashFunc3()(key) % N;if (_bs.test(hash3) == false){return false;}// 存在误判的return true;}private:ljh::bitset<N> _bs;
};

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

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

相关文章

应急救灾北斗终端手机应用方案

在应对自然灾害和紧急救援的严峻挑战中&#xff0c;技术的力量从未如此重要。为了保障救援人员能够迅速、准确地响应灾情&#xff0c;提供及时有效的救助&#xff0c;顶坚应急救灾北斗终端手机应用应运而生。这款应用依托北斗卫星导航系统的高精度定位与通信功能&#xff0c;不…

谁考了第k名C++

题目描述 在一次考试中&#xff0c;每个学生的成绩都不相同&#xff0c;现知道了每个学生的学号和成绩&#xff0c;求考第k名学生的学号和成绩。&#xff08;按成绩从大到小排列&#xff09; 输入 第一行有两个整数&#xff0c;分别是学生的人数n&#xff08;1≤n≤100&…

MWM燃气发动机TEM控制系统维修TEM-EVO触摸屏 工业液晶显示屏深圳捷达工控维修

MWM 燃气发动机、发电机组、发电机组、热电联产、热电联产厂、热电联产 MWM 是高效、环保的热电联产发电厂市场领域的世界领先品牌之一&#xff0c;该发电厂用于利用热电联产 (CHP)进行分散式发电。这家总部位于曼海姆的公司由卡尔奔驰 (Carl Benz) 于 1871 年创立&#xff0c;…

图扑智慧农业——生态鱼塘数字孪生监控

智慧农业园作为新型农业经营模式&#xff0c;正在以其高效、环保、可持续的特点受到广泛关注。智慧鱼塘作为智慧农业中一项关键技术&#xff0c;结合物联网、人工智能、云计算等技术&#xff0c;实现对新型养殖模式的实时监控、优化与管理。 效果展示 图扑软件应用自研 HT for…

java如何直接读取excel文件进行增删改查操作

首先先创建一个文件路径类,用来放置文件的位置 package com.ruoyi.web.core.config;import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Configuration; import org.springfra…

巩固学习7

正则表达式 就是用来找到符合模式的字符串&#xff0c;这些模式包括&#xff1a;是什么字符&#xff0c;重复多少次&#xff0c;在什么位置&#xff0c;有哪些额外的约束 找某个字符串 import re text身高:178 体重:168 学号:123456 密码:9527 #在Python中&#xff0c;r前缀用…

登录uniapp存入token方便其他页面用

// 登录函数 function login(username, password) {// 假设这是你的登录接口const loginUrl https://your-api-domain.com/login;// 使用uni.request发送登录请求uni.request({url: loginUrl,method: POST,data: {username: username,password: password},success: (res) >…

数据库种类

关系型数据库是目前应用最广泛的数据库类型。它诞生于1969年&#xff0c;并采用由行和列组成的二维表来管理数据&#xff0c;这种结构与Excel工作表相似&#xff0c;因此易于理解和使用。关系型数据库主要使用SQL&#xff08;结构化查询语言&#xff09;来进行数据操作。传统的…

BFD双向转发检测

BFD概述 Bidirectional Forwarding Detection &#xff1a;双向转发检测 BFD技术背景 现网中存在的问题 不能快速有效的发现网络设备或链路中出现的故障不能以毫秒级的速度发现网络中的问题协议自身的报文检测机制一般都大于1秒 解决方案&#xff1a; 需要一种专门用于快…

【脚本】使用脚本备份docker中部署的mysql数据库

v1版本明文密码方式&#xff1a; #!/bin/bash# 定义 MySQL 容器名称和数据库信息 container_name"mysql_container" db_user"root" db_password"your_password"# 定义要备份的数据库列表 databases("database1" "database2"…

cannot find symbol [ERROR] symbol: class BASE64Decoder报错解决(亲测可用)

在用Jenkins部署项目的时候&#xff0c;控制台突然报了如下错误&#xff1a; cannot find symbol symbol: class BASE64Decoder location: package sun.misc [INFO] 1 error BUILD FAILURE Total time: 16.117 s 解决方案&#xff1a; java包引入&#xff1a; import su…

阿赵UE引擎C++编程学习笔记——字符串操作

大家好&#xff0c;我是阿赵   之前在介绍了UE的log打印。打印输入的参数是字符串。这里来学习一下&#xff0c;UE里面字符串有哪些类型&#xff0c;还有一些常用的字符串处理方法。 一、 FName、FString、FText 1、 三种格式的介绍 在打印方法里面&#xff0c;输入的字符串…

Outlook的IMAP服务器怎么填写?填写步骤?

Outlook的IMAP服务器如何使用&#xff1f;服务器地址怎么查找&#xff1f; 当我们在Outlook中设置新的电子邮件账户时&#xff0c;经常会遇到一个问题&#xff1a;Outlook的IMAP服务器怎么填写呢&#xff1f;接下来&#xff0c;AokSend将详细解答这个问题&#xff0c;并帮助大…

Dive into Deep Learning-优化算法(2)

梯度下降 为什么梯度下降可以优化目标函数&#xff1a;以一维梯度下降为例 f : R → R f:\mathbb{R}\rightarrow\mathbb{R} f:R→R&#xff0c;利用泰勒展开&#xff0c;可以得到&#xff1a; f ( x ϵ ) f ( x ) ϵ f ′ ( x ) O ( ϵ 2 ) f(x \epsilon) f(x) \epsilo…

400元已到账,成交从认真开始

昨天发了一个值班的需求&#xff0c;收到了很多好友的响应&#xff0c;这里非常感谢关注创业程序员卡酷的老朋友、新朋友。今天分享一下&#xff1a;拓展、合作、成交 现在不管是IT行业还是其他行业&#xff0c;大环境可谓一片惨淡&#xff0c;35乃至30找不到工作的失业人员一抓…

深度论证-高速走线控制100欧姆阻抗一定是最好的选择吗?

高速先生成员--黄刚 对于高速差分信号到底需要控制多少欧姆的阻抗&#xff0c;高速先生相信大部分工程师首先都会看下例如信号的协议文档或者芯片的文档&#xff0c;看看里面有没有推荐的控制阻抗值。例如像PCIE信号&#xff0c;在4.0之后的阻抗会明确要求按照85欧姆来控制&…

4.Jmeter阶梯加压Stepping Thread Group

1. 先去Jmeter下载地址下载PluginsManager&#xff0c;放置在Jmeter的lib/ext 目录下 &#xff0c;重启Jmeter 2. 在插件管理器查找并安装jpgc - Standard Set,重启Jmeter 3.右键测试计划->添加->Threads(Users)->jpgc - Stepping Thread Group 然后设置阶梯加压参数…

SAP_ABAP_快速了解_指针

首先abap里有下面几种数据类型 变量&#xff0c;结构和内表 来看下面的比喻&#xff1a; 变量 房间 结构 平房&#xff08;里面有很多房间&#xff1b;是一户人家&#xff09; 内表 楼房&#xff08;有很多层&#xff0c;每层有很多户人家&#xff0c;每户人家又有很多…

贷款没有逾期,征信没问题,为什么大数据信用评分低呢?

大数据信用在金融贷前风控越来越重要&#xff0c;这让不少人开始关心自己的大数据信用了&#xff0c;其中就有不少人有疑问&#xff0c;那就是自己网贷没有逾期&#xff0c;征信记录也还可以&#xff0c;为什么大数据信用评分低呢?这个问题也是不少人都想知道的&#xff0c;小…

鸿蒙开发之跨设备文件访问

分布式文件系统为应用提供了跨设备文件访问的能力&#xff0c;开发者在多个设备安装同一应用时&#xff0c;通过基础文件接口&#xff0c;可跨设备读写其他设备该应用分布式文件路径&#xff08;/data/storage/el2/distributedfiles/&#xff09;下的文件。 例如&#xff1a;多…