哈希表的简单模拟实现

文章目录

  • 底层结构
  • 哈希冲突
  • 闭散列
    • 定义哈希节点
    • 定义哈希表
    • **哈希表什么情况下进行扩容？如何扩容？**
    • Insert()函数
    • Find()函数
    • 二次探测
    • HashFunc()仿函数
    • Erase()函数
    • 全部的代码
  • 开散列
    • 定义哈希节点
    • 定义哈希表
    • Insert()函数
    • Find()函数
    • Erase()函数
    • 总代码

初识哈希

哈希表是一种查找效率及其高的算法，最理想的情况下查询的时间复杂度为O(1)。

unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率

较低。

底层结构

unordered系列的关联式容器之所以效率更高，是因为底层采用了哈希的结构。

哈希是通过对key进行映射，然后通过映射值直接去拿到要的数据，效率更高，平衡树的查找是通过依次比对，相对而言就会慢一些。

  • 插入元素：通过计算出元素的映射值，来后通过映射值把元素插入到储存的位置当中。
  • 搜索元素：通过计算元素的映射值来取得元素。

哈希方法中使用的转换函数称之为哈希(散列)函数，构造出来的结构叫做哈希表(散列表)

例: 集合 {1，7，6，4，5，9，11，21}；

哈希函数为：hash(key)=key%capacity，capacity为底层空间的最大值。

0123456789
111214569

1%10=1、4%10=4、7%10=10…

但如果我要插入一个11怎么办？

这就是一个经典的问题，哈希冲突

哈希冲突

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

闭散列

闭散列也叫开放寻址法，当发生冲突的时候我就往后面去找，假如1和11去%10都等于1，但是1先去把1号坑位占了，那么11肯定不能把1的坑位抢了，只能往后找有没有没有被占的坑位，有的话就放11，这个方法叫做线性探测法。

但是我要删除某个值该怎么办呢？

0123456789
111214569

例如这段数据，我把11删掉之后

0123456789
1214569

2的位置就空出来了，当我想要去找21的时候会发现找不到，因为找某个值和插入某个值是一样的，先确定映射值，如果不是当前值就往后面找，如果为空就找完了，这里2为空，不能继续往后找了，就要返回查找失败了，但是21是存在的呀，所以可以对每一个哈希节点进行标记，在每一个节点中记录一个状态值，是Empty还是Exit还是Delete，这样就可以避免上述情况了。

定义哈希节点

	//枚举状态enum State{Empty,Exit,Delete};template<class K,class V>struct Hash_Node{pair<K, V> _kv;State _state = Empty;};

定义哈希表

	template<class K,class V>class Hash_table{public:typedef Hash_Node<K, V> Node;private:vector<Node> _tables;size_t _size=0;};

哈希表什么情况下进行扩容？如何扩容？

Insert()函数

bool Insert(const pair<K,V>& key){//查重if (Find(key.first)){return false;}//扩容if (_tables.size()==0||10*_size / _tables.size()>=7){//大于7需要扩容size_t newSize = _tables.size() == 0 ? 10 : 2 * _tables.size();Hash_table<K, V>newHT;newHT._tables.resize(newSize);//新表//复用Insert函数for (auto& e : _tables){if (e._state == Exit){newHT.Insert(e._kv);}}_tables.swap(newHT._tables);}//线性探测size_t hashi = key.first % _tables.size();while (_tables[hashi]._state == Exit){hashi++;hashi %= _tables.size();}_tables[hashi]._kv = key;_tables[hashi]._state = Exit;_size++;return true;}

Find()函数

Hash_Node<K, V>* Find(const K& key){if (_tables.size() == 0) return nullptr;size_t start = key % _tables.size();size_t begin = start;while (_tables[start]._state != Empty){if (_tables[start]._state != Delete && _tables[start]._kv.first == key){return &_tables[start];}start++;start %= _tables.size();if (begin == start){break;}}return nullptr;}

样例测试

	void test1(){int arr[] = { 1,2,3,4,5,6,7,8,9,10,11,12,21,31,41,51,61,71,81,91,101 };Hash_table<int, int>hs;for (auto e : arr){hs.Insert(make_pair(e, e));}}

测试结果如下：

可以看到都是被成功的插入了。

线性探测的优先：简单方便。

线性探测的缺点：一旦发生哈希冲突了，所有的冲突都会堆积在一块，会导致查找的效率变得很低。

二次探测

二次探测其实就是每次跳过i的平方个间隔，原来的线性探测是一个一个往后找。

0123456789
ExitExitExit

比如在1发生了哈希冲突，那么线性探测就会去找2位置，然后再找3位置，直到找到空为止。

但二次探测是1没有，i=1，i的平方等于1，找2位置，i=2，i的平方等于4，找5位置，发现没有元素，就直接占位，二次探测可以让数据更加分散，降低哈希冲突的发生率。

		size_t start = hash(kv.first) % _tables.size();size_t i = 0;size_t hashi = start;// 二次探测while (_tables[hashi]._state == Exit){++i;hashi = start + i*i;hashi %= _tables.size();}_tables[hashi]._kv = kv;_tables[hashi]._state = EXIST;++_size;

以上的哈希表只能用来映射int类型的值，如果是其他类型就不行了，这里可以增加一个仿函数来兼容其他类型，这里最重要的是string类型了，如何才能将string类型转换为一个数值。

我们可以把ASCII码相加，就能得到key了，但是面对以下场景就会哈希冲突了。

string str1="abc";
string str2="acb";
string str3="cba";

这里有大佬得出过一个结论

hash = hash * 131 + ch，这样可以降低哈希碰撞的概率。

HashFunc()仿函数

	template<class K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//特例化模板参数来解决string的问题template<>struct HashFunc<string>{size_t operator()(const string& key){size_t val = 0;for (auto ch : key){val *= 131;val += ch;}return val;}};

#pragma once
#include<iostream>
#include<set>
#include<vector>
using namespace std;//闭散列
namespace mudan
{template<class K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//特例化模板参数来解决string的问题template<>struct HashFunc<string>{size_t operator()(const string& key){size_t val = 0;for (auto ch : key){val *= 131;val += ch;}return val;}};enum State{Empty,Exit,Delete};template<class K,class V>struct Hash_Node{pair<K, V> _kv;State _state = Empty;};template<class K,class V,class Hash=HashFunc<K>>class Hash_table{public:typedef Hash_Node<K, V> Node;bool Insert(const pair<K,V>& key){//查重if (Find(key.first)){return false;}//扩容if (_tables.size()==0||10*_size / _tables.size()>=7){//大于7需要扩容size_t newSize = _tables.size() == 0 ? 10 : 2 * _tables.size();Hash_table<K, V>newHT;newHT._tables.resize(newSize);//新表//复用Insert函数for (auto &e : _tables){if (e._state == Exit){newHT.Insert(e._kv);}}_tables.swap(newHT._tables);}Hash hash;//线性探测size_t hashi = hash(key.first) % _tables.size();while (_tables[hashi]._state == Exit){hashi++;hashi %= _tables.size();}_tables[hashi]._kv = key;_tables[hashi]._state = Exit;_size++;return true;}Hash_Node<K, V>* Find(const K& key){if (_tables.size() == 0) return nullptr;Hash hash;size_t start = hash(key) % _tables.size();size_t begin = start;while (_tables[start]._state != Empty){if (_tables[start]._state != Delete && _tables[start]._kv.first == key){return &_tables[start];}start++;start %= _tables.size();if (begin == start){break;}}return nullptr;}private:vector<Node> _tables;size_t _size;};void TestHT2(){string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };//HashTable<string, int, HashFuncString> countHT;Hash_table<string, int> countHT;for (auto& str : arr){auto ptr = countHT.Find(str);if (ptr){ptr->_kv.second++;}else{countHT.Insert(make_pair(str, 1));}}}void test1(){int arr[] = { 1,2,3,4,5,6,7,8,9,10,11,12,21,31,41,51,61,71,81,91,101 };Hash_table<int, int>hs;for (auto e : arr){hs.Insert(make_pair(e, e));}}
}

可以看到映射也成功了。

对于之前说的问题也解决了。

string str1="abc";
string str2="acb";
string str3="cba";

Erase()函数

这个就简单了，Erase不是真正意义上把这个数字从数组当中删掉，而是改变状态，把状态改成Delete即可。

		bool Erase(const K& key){Hash_Node<K, V>* ret = Find(key);if (ret){ret->_state = Delete;--_size;return true;}else{return false;}}

全部的代码

#pragma once
#include<iostream>
#include<set>
#include<vector>
using namespace std;//闭散列
namespace mudan
{template<class K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//特例化模板参数来解决string的问题template<>struct HashFunc<string>{size_t operator()(const string& key){size_t val = 0;for (auto ch : key){val *= 131;val += ch;}return val;}};enum State{Empty,Exit,Delete};template<class K,class V>struct Hash_Node{pair<K, V> _kv;State _state = Empty;};template<class K,class V,class Hash=HashFunc<K>>class Hash_table{public:typedef Hash_Node<K, V> Node;bool Insert(const pair<K,V>& key){//查重if (Find(key.first)){return false;}//扩容if (_tables.size()==0||10*_size / _tables.size()>=7){//大于7需要扩容size_t newSize = _tables.size() == 0 ? 10 : 2 * _tables.size();Hash_table<K, V>newHT;newHT._tables.resize(newSize);//新表//复用Insert函数for (auto &e : _tables){if (e._state == Exit){newHT.Insert(e._kv);}}_tables.swap(newHT._tables);}Hash hash;//线性探测size_t hashi = hash(key.first) % _tables.size();while (_tables[hashi]._state == Exit){hashi++;hashi %= _tables.size();}_tables[hashi]._kv = key;_tables[hashi]._state = Exit;_size++;return true;}Hash_Node<K, V>* Find(const K& key){if (_tables.size() == 0) return nullptr;Hash hash;size_t start = hash(key) % _tables.size();size_t begin = start;while (_tables[start]._state != Empty){if (_tables[start]._state != Delete && _tables[start]._kv.first == key){return &_tables[start];}start++;start %= _tables.size();if (begin == start){break;}}return nullptr;}bool Erase(const K& key){Hash_Node<K, V>* ret = Find(key);if (ret){ret->_state = Delete;--_size;return true;}else{return false;}}private:vector<Node> _tables;size_t _size=0;};void TestHT2(){string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };//HashTable<string, int, HashFuncString> countHT;Hash_table<string, int> countHT;for (auto& str : arr){auto ptr = countHT.Find(str);if (ptr){ptr->_kv.second++;}else{countHT.Insert(make_pair(str, 1));}}}void test1(){int arr[] = { 1,2,3,4,5,6,7,8,9,10,11,12,21,31,41,51,61,71,81,91,101 };Hash_table<int, int>hs;for (auto e : arr){hs.Insert(make_pair(e, e));}}void TestHT3(){HashFunc<string> hash;cout << hash("abcd") << endl;cout << hash("bcad") << endl;cout << hash("eat") << endl;cout << hash("ate") << endl;cout << hash("abcd") << endl;cout << hash("aadd") << endl << endl;cout << hash("abcd") << endl;cout << hash("bcad") << endl;cout << hash("eat") << endl;cout << hash("ate") << endl;cout << hash("abcd") << endl;cout << hash("aadd") << endl << endl;}
}

开散列

开散列如上图所示，他有一个桶子来表示key值，然后key值相同的(哈希冲突的)就都连接到这个桶的key对应的位置下面。

这个桶其实就是一个指针数组。

定义哈希节点

	template<class K,class V>struct HashNode{pair<K, V> _kv;HashNode<K,V>* _next;HashNode(const pair<K,V>& data):_kv(data),_next(nullptr){}};

定义哈希表

template<class K, class V, class Hash = HashFunc<K>>class HashTable{typedef HashNode<K, V> Node;public:private:vector<Node*>_tables;size_t _size=0;};

Insert()函数

插入操作头插和尾插都很快，这里由于定义的是单链表，就选择头插了。

插入过程如下图所示：

bool Insert(const pair<K, V>& key){Hash hash;//去重if (Find(key.first)) return false;//负载因子等于1就要扩容了if (_size == _tables.size()){size_t newsize = _tables.size() == 0 ? 10:2 * _tables.size();vector<Node*>newTables;newTables.resize(newsize);for (int i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;size_t hashi = hash(cur->_kv.first) % newTables.size();cur->_next =newTables[hashi];newTables[hashi] = cur;cur = next;}_tables[i] = nullptr;//销毁原来的桶}_tables.swap(newTables);}//头插//  head//    1     2头插，2->next=1,head=2;size_t hashi = hash(key.first) % _tables.size();Node* newnode = new Node(key);newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_size;return true;}

Find()函数

		Node* Find(const K& key){if (_tables.size() == 0){return nullptr;}Hash hash;size_t hashi = hash(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){return cur;}cur = cur->_next;}//没找到，返回空return nullptr;}

Erase()函数

和链表的和删除一摸一样

bool Erase(const K& key){if (_tables.size() == 0){return nullptr;}Hash hash;size_t hashi = hash(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){// 1、头删// 2、中间删if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;--_size;return true;}prev = cur;cur = cur->_next;}return false;}

总代码

#pragma once
#include<iostream>
#include<set>
#include<vector>
using namespace std;//闭散列
namespace mudan
{template<class K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//特例化模板参数来解决string的问题template<>struct HashFunc<string>{size_t operator()(const string& key){size_t val = 0;for (auto ch : key){val *= 131;val += ch;}return val;}};enum State{Empty,Exit,Delete};template<class K,class V>struct Hash_Node{pair<K, V> _kv;State _state = Empty;};template<class K,class V,class Hash=HashFunc<K>>class Hash_table{public:typedef Hash_Node<K, V> Node;bool Insert(const pair<K,V>& key){//查重if (Find(key.first)){return false;}//扩容if (_tables.size()==0||10*_size / _tables.size()>=7){//大于7需要扩容size_t newSize = _tables.size() == 0 ? 10 : 2 * _tables.size();Hash_table<K, V>newHT;newHT._tables.resize(newSize);//新表//复用Insert函数for (auto &e : _tables){if (e._state == Exit){newHT.Insert(e._kv);}}_tables.swap(newHT._tables);}Hash hash;//线性探测size_t hashi = hash(key.first) % _tables.size();while (_tables[hashi]._state == Exit){hashi++;hashi %= _tables.size();}_tables[hashi]._kv = key;_tables[hashi]._state = Exit;_size++;return true;}Hash_Node<K, V>* Find(const K& key){if (_tables.size() == 0) return nullptr;Hash hash;size_t start = hash(key) % _tables.size();size_t begin = start;while (_tables[start]._state != Empty){if (_tables[start]._state != Delete && _tables[start]._kv.first == key){return &_tables[start];}start++;start %= _tables.size();if (begin == start){break;}}return nullptr;}bool Erase(const K& key){Hash_Node<K, V>* ret = Find(key);if (ret){ret->_state = Delete;--_size;return true;}else{return false;}}private:vector<Node> _tables;size_t _size=0;};void TestHT2(){string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };//HashTable<string, int, HashFuncString> countHT;Hash_table<string, int> countHT;for (auto& str : arr){auto ptr = countHT.Find(str);if (ptr){ptr->_kv.second++;}else{countHT.Insert(make_pair(str, 1));}}}void test1(){int arr[] = { 1,2,3,4,5,6,7,8,9,10,11,12,21,31,41,51,61,71,81,91,101 };Hash_table<int, int>hs;for (auto e : arr){hs.Insert(make_pair(e, e));}}void TestHT3(){HashFunc<string> hash;cout << hash("abcd") << endl;cout << hash("bcad") << endl;cout << hash("eat") << endl;cout << hash("ate") << endl;cout << hash("abcd") << endl;cout << hash("aadd") << endl << endl;cout << hash("abcd") << endl;cout << hash("bcad") << endl;cout << hash("eat") << endl;cout << hash("ate") << endl;cout << hash("abcd") << endl;cout << hash("aadd") << endl << endl;}
}namespace mudan1
{template<class K>struct HashFunc{size_t operator()(const K& key){return (size_t)key;}};//特例化模板参数来解决string的问题template<>struct HashFunc<string>{size_t operator()(const string& key){size_t val = 0;for (auto ch : key){val *= 131;val += ch;}return val;}};template<class K,class V>struct HashNode{pair<K, V> _kv;HashNode<K,V>* _next;HashNode(const pair<K,V>& data):_kv(data),_next(nullptr){}};template<class K, class V, class Hash = HashFunc<K>>class HashTable{typedef HashNode<K, V> Node;public:bool Insert(const pair<K, V>& key){Hash hash;//去重if (Find(key.first)) return false;//负载因子等于1就要扩容了if (_size == _tables.size()){size_t newsize = _tables.size() == 0 ? 10:2 * _tables.size();vector<Node*>newTables;newTables.resize(newsize);for (int i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;size_t hashi = hash(cur->_kv.first) % newTables.size();cur->_next =newTables[hashi];newTables[hashi] = cur;cur = next;}_tables[i] = nullptr;//销毁原来的桶}_tables.swap(newTables);}//头插//  head//    1     2头插，2->next=1,head=2;size_t hashi = hash(key.first) % _tables.size();Node* newnode = new Node(key);newnode->_next = _tables[hashi];_tables[hashi] = newnode;++_size;return true;}Node* Find(const K& key){if (_tables.size() == 0){return nullptr;}Hash hash;size_t hashi = hash(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){if (_tables.size() == 0){return nullptr;}Hash hash;size_t hashi = hash(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key){// 1、头删// 2、中间删if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;--_size;return true;}prev = cur;cur = cur->_next;}return false;}private:vector<Node*>_tables;size_t _size=0;};void TestHT1(){int a[] = { 1, 11, 4, 15, 26, 7, 44,55,99,78 };HashTable<int, int> ht;for (auto e : a){ht.Insert(make_pair(e, e));}ht.Insert(make_pair(22, 22));}
}

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

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

相关文章

UG\NX二次开发 获取2D制图视图中可见的对象，并获取类型

UG\NX二次开发 获取2D制图视图中可见的对象，并获取类型

文章作者：里海 来源网站：https://blog.csdn.net/WangPaiFeiXingYuan 简介： 使用UF_VIEW_ask_visible_objects获取2D制图视图中可见的对象，并获取类型。 下面是将一个六面体以不同的视图投影，获取视图对象和类型的效果。 效果： 1个部件事例，1个体，4条边 1个部件事…
阅读更多...
springboot创建并配置环境(一) - 创建环境

springboot创建并配置环境(一) - 创建环境

文章目录 一、介绍二、启动环境Environment的分析三、进入源码四、创建环境1. 如何确定应用类型2. 测试 一、介绍 在springboot的启动流程中&#xff0c;启动环境Environment是可以说是除了应用上下文ApplicationContext之外最重要的一个组件了&#xff0c;而且启动环境为应用…
阅读更多...
MySQL主从复制

MySQL主从复制

1.理解MySQL主从复制原理。 1.1MySQL支持的复制类型 MySQL支持以下几种常见的复制类型&#xff1a; 基于语句的复制&#xff08;Statement-based Replication&#xff0c;SBR&#xff09;&#xff1a;基于语句的复制是MySQL最早支持的复制方式&#xff0c;它通过复制和执行S…
阅读更多...
CSS3 实现边框圆角渐变色渐变文字效果

CSS3 实现边框圆角渐变色渐变文字效果

.boder-txt {width: 80px;height: 30px; line-height: 30px;padding: 5px;text-align: center;border-radius: 10px;border: 6rpx solid transparent;background-clip: padding-box, border-box;background-origin: padding-box, border-box;/*第一个linear-gradient表示内填充…
阅读更多...
C++动态内存管理

C++动态内存管理

目录 C语言中的动态内存管理C动态内存管理动态管理内置类型动态管理自定义类型 new和delete的实现原理operator new和operator delete函数new和delete对内置类型的实现原理new和delete对自定义类型的实现原理 malloc/free和new/delete区别 C语言中的动态内存管理 之前学习了C语…
阅读更多...
Nginx系列之 一 负载均衡

Nginx系列之 一 负载均衡

目录 一、Nginx概述 1.1 负载均衡概述 1.2 负载均衡的作用 1.3 四/七层负载均衡 1.3.1 网络模型简介 1.3.2 四层和七层负载均衡对比 1.3.3 Nginx七层负载均衡实现 1.4 Nginx负载均衡配置 1.5 Nginx负载均衡状态 1.6 Nginx负载均衡策略 二、负载均衡实战 2.1 测试服…
阅读更多...
算法通关村第一关——链表白银挑战笔记

算法通关村第一关——链表白银挑战笔记

文章目录 两个链表的第一个重合节点判断回文链表 两个链表的第一个重合节点 同LeetCode 160.相交链表 解法一&#xff1a;Hash和Set(集合&#xff09;&#xff0c;此处用Set合适。 把其中一个链表的所有节点引用放入set&#xff0c;再从头遍历另一个链表第一次重合的地方就是答…
阅读更多...
Android性能优化之SharedPreference卡顿优化

Android性能优化之SharedPreference卡顿优化

下面的源码都是基于Android api 31 1、SharedPreference使用 val sharePref getPreferences(Context.MODE_PRIVATE) with(sharePref.edit()) { putBoolean("isLogin", true)putInt("age", 18)apply() } val isLogin sharePref.getBoolean("isLogi…
阅读更多...
windows环境下docker数据迁移到其他盘

windows环境下docker数据迁移到其他盘

docker安装在C盘&#xff0c;使用一段时间后&#xff0c;C盘爆满。因此想把C盘中的数据迁移到其他盘&#xff0c;以释放C盘空间。分为以下步骤&#xff1a; 1、启动docker软件&#xff0c;打开PowerShell并切换到Docker Compose配置文件的目录。 Docker Compose配置文件的目录…
阅读更多...
通过社区参与解锁早期增长：Maven 远程医疗平台概览

通过社区参与解锁早期增长：Maven 远程医疗平台概览

Maven通过用户导向的渐进式验证&#xff0c;找到了一个被忽视的巨大女性医疗服务市场&#xff0c;作为女性医疗保健的先行者&#xff0c;已服务超过1500万用户&#xff0c;目前估值已达$14亿。本文将深入探索Maven实现产品市场匹配的三个阶段&#xff0c;从如何验证初始的市场机…
阅读更多...
Vue2基础十、Vuex

Vue2基础十、Vuex

零、文章目录 Vue2基础十、Vuex 1、vuex概述 &#xff08;1&#xff09;vuex是什么 vuex 是一个 vue 的 状态管理工具&#xff0c;状态就是数据。大白话&#xff1a;vuex 是一个插件&#xff0c;可以帮我们管理 vue 通用的数据 (多组件共享的数据) 例如&#xff1a;购物车数…
阅读更多...
Linux安装部署Nacos和sentinel

Linux安装部署Nacos和sentinel

1.将nacos安装包下载到本地后上传到linux中 2.进入nacos的/bin目录,输入命令启动nacos [rootlocalhost bin]# sh startup.sh -m standalone注:使用第二种方式启动,同时增加日志记录的功能 2.2 startup.sh文件是不具备足够的权限,否则不能操作 给文件赋予执行权限 [rootlocalh…
阅读更多...
【lesson5】linux vim介绍及使用

【lesson5】linux vim介绍及使用

文章目录 vim的基本介绍vim的基本操作vim常见的命令命令模式下的命令yypnyynpuctrlrGggnG$^wbh,j,k,lddnddnddp~shiftrrnrxnx 底行模式下的命令set nuset nonuvs 源文件wq!command&#xff08;命令&#xff09; vim配置解决无法使用sudo问题 vim的基本介绍 首先vim是linux下的…
阅读更多...
十、数据结构——链式队列

十、数据结构——链式队列

数据结构中的链式队列 目录 一、链式队列的定义 二、链式队列的实现 三、链式队列的基本操作 ①初始化 ②判空 ③入队 ④出队 ⑤获取长度 ⑥打印 四、循环队列的应用 五、总结 六、全部代码 七、结果 在数据结构中&#xff0c;队列&#xff08;Queue&#xff09;是一种常见…
阅读更多...
react-router-dom和react-router的区别

react-router-dom和react-router的区别

react-router-dom和react-router的区别 前言 在使用react-router-dom的时候&#xff0c;经常会和react-router搞混了&#xff0c;搞不清楚它们哪个跟哪&#xff0c;到底有什么关系&#xff0c;今天来总结一下。 结论 react-router-dom是在react-router的基础上开发的&#…
阅读更多...
变现：利用 chatgpt + midjourney 制作微信表情包

变现：利用 chatgpt + midjourney 制作微信表情包

1、利用gpt生成提示词&#xff0c;当然也可以直接翻译 生成基础提示词&#xff0c; 比如&#xff1a; an anime image with a white kawaii character in it, in the style of light green and brown, minimalist detail, animated gifs, cranberrycore, 1860–1969, babyco…
阅读更多...
C#实现数字验证码

C#实现数字验证码

开发环境&#xff1a;VS2019&#xff0c;.NET Core 3.1&#xff0c;ASP.NET Core API 1、建立一个验证码控制器 新建两个方法Create和Check&#xff0c;Create用于创建验证码&#xff0c;Check用于验证它是否有效。 声明一个静态类变量存放列表&#xff0c;列表中存放包含令…
阅读更多...
python selenium爬虫自动登录实例

python selenium爬虫自动登录实例

拷贝地址&#xff1a;python selenium爬虫自动登录实例_python selenium登录_Ustiniano的博客-CSDN博客 一、概述 我们要先安装selenium这个库&#xff0c;使用pip install selenium 命令安装&#xff0c;selenium这个库相当于机器模仿人的行为去点击浏览器上的元素&#xff0…
阅读更多...
Android ANR触发机制之Service ANR

Android ANR触发机制之Service ANR

一、前言 在Service组件StartService()方式启动流程分析文章中&#xff0c;针对Context#startService()启动Service流程分析了源码&#xff0c;其实关于Service启动还有一个比较重要的点是Service启动的ANR&#xff0c;因为因为线上出现了上百例的"executing service &quo…
阅读更多...
R-并行计算

R-并行计算

本文介绍在计算机多核上通过parallel包进行并行计算。 并行计算运算步骤&#xff1a; 加载并行计算包&#xff0c;如library(parallel)。创建几个“workers”,通常一个workers一个核&#xff08;core&#xff09;&#xff1b;这些workers什么都不知道&#xff0c;它们的全局环…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023