哈希表、unordered_map和unordered_set模拟

news2025/1/13 15:36:45

目录

哈希表

闭散列

开散列

unordered_map和unordered_set模拟

对开散列的哈希表改造

unordered_set模拟

unordered_map模拟

哈希表

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

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

插入元素：根据待插入的元素的关键码，以此函数计算出该元素的存放位置并存放。

搜索元素：根据元素的关键码，计算出该元素的存放位置，在该位置取元素比较，如果关键码相等，则查找成功。

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

常见哈希函数----->1. 直接定址法--(常用)2. 除留余数法--(常用)

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

闭散列

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

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

//线性探测
size_t start = val.first % _ht.size();
size_t i = 0;
size_t index = start;
while (_ht[index]._state == EXIST) {
	i++;
	index = start + i;
	index %= _ht.size();
}

插入

        1、通过哈希函数获取待插入元素在哈希表中的位置

        2、如果该位置没有元素则直接插入新元素，如果该位置中发生哈希冲突，则使用线性探测找到下一个空位置，插入新元素。

 删除

        采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素会影响其他元素的搜索（ps：因为对于其他元素的查找遇见EMPTY即停止查找）。因此，线性探测采用标记来删除一个元素。

闭散列实现如下：

template<class K>//仿函数处理key
struct Hash {
	size_t operator()(const K& key) {
		return key;
	}
};
template<>
struct Hash<string> {
	size_t operator()(const string& s) {
		size_t value = 0;
		for (auto e : s) {
			value *= 31;
			value += e;
		}
		return value;
	}
};

namespace closeHash {
	enum State {
		EXIST,
		DELETE,
		EMPTY
	};
	template<class K,class V>
	struct HashData {
		pair<K, V> _kv;
		State _state = EMPTY;
	};
	template<class K,class V,class HashFunc = Hash<K>>
	class HashTable {
	public:
		bool Erase(const K& key) {
			HashData<K, V>* ret = Find(key);
			if (ret == nullptr)
				return false;
			else {
				_n--;
				ret->_state = DELETE;
				return true;
			}
		}
		HashData<K, V>* Find(const K& key) {
			if (_table.size() == 0)
				return nullptr;
			HashFunc hf;
			size_t start = hf(key) % _table.size();
			size_t i = 0;
			size_t index = start;
			while (_table[index]._state != EMPTY) {
				if (_table[index]._kv.first == key && _table[index]._state == EXIST)
					return &_table[index];
				i++;
				index = start + i;
				index %= _table.size();
			}
			return nullptr;
		}
		bool Insert(const pair<K, V>& kv) {
			HashData<K, V>* ret = Find(kv.first);
			if (ret)
				return false;
			if (_table.size() == 0 || _n * 10 / _table.size() > 7) {
				//扩容
				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
				HashTable<K, V> newTable;
				newTable._table.resize(newSize);
				for (size_t i = 0; i < _table.size(); i++) {
					if (_table[i]._state == EXIST)
						newTable.Insert(_table[i]._kv);
				}
				_table.swap(newTable._table);
			}
			HashFunc hf;
			size_t start = hf(kv.first) % _table.size();
			size_t i = 0;
			size_t index = start;
			while (_table[index]._state != EMPTY) {
				i++;
				index = start + i;
				index %= _table.size();
			}
			_table[index]._kv = kv;
			_table[index]._state = EXIST;
			_n++;
			return true;
		}
	private:
		vector<HashData<K, V>> _table;
		size_t _n;
	};
	void test() {
		HashTable<int, int> ht;
		int a[] = { 2,12,22,32,42,52,62 };
		for (auto& e : a) {
			ht.Insert(make_pair(e, e));
		}
		ht.Insert(make_pair(72, 72));
		ht.Insert(make_pair(32, 32));
		//ht.Insert(make_pair(-1, -1));
		ht.Insert(make_pair(-999, -999));

		cout << ht.Find(12) << endl;
		ht.Erase(12);
		cout << ht.Find(12) << endl;
	}
}

开散列

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

开散列的增容：桶的个数是一定的，随着元素的不断插入，每个桶中元素的个数不断增多，极端情况下，可 能会导致一个桶中链表节点非常多，会影响的哈希表的性能，因此在一定条件下需要对哈希 表进行增容，那该条件怎么确认呢？开散列最好的情况是：每个哈希桶中刚好挂一个节点， 再继续插入元素时，每一次都会发生哈希冲突，因此，在元素个数刚好等于桶的个数时，可以给哈希表增容。

size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;

开散列实现如下：

template<class K>//仿函数处理key
struct Hash {
	size_t operator()(const K& key) {
		return key;
	}
};
template<>
struct Hash<string> {
	size_t operator()(const string& s) {
		size_t value = 0;
		for (auto e : s) {
			value *= 31;
			value += e;
		}
		return value;
	}
};
namespace openHash {
	template<class K,class V>
	struct HashNode {
		pair<K, V> _kv;
		HashNode<K, V>* _next;
		HashNode(const pair<K,V>& kv)
			:_kv(kv)
			,_next(nullptr)
		{}
	};
	template<class K,class V,class HashFunc = Hash<V>>
	class HashBucket {
		typedef HashNode<K, V> Node;
	public:
		bool Erase(const K& key) {
			if (_table.empty())
				return false;
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			Node* prev = nullptr;
			while (cur) {
				if (cur->_kv.first == key) {
					if (prev == nullptr)
						_table[index] = cur->_next;
					else
						prev->_next = cur->_next;
					delete cur;
					_n--;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
		Node* Find(const K& key) {
			if (_table.empty())
				return nullptr;
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			while (cur) {
				if (cur->_kv.first == key)
					return cur;
				cur = cur->_next;
			}
			return nullptr;
		}
		bool Insert(const pair<K, V>& kv) {
			Node* ret = Find(kv.first);
			if (ret)
				return false;
			HashFunc hf;
			if (_n == _table.size()) {
				//扩容
				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
				vector<Node*> newBucket;
				newBucket.resize(newSize);
				for (size_t i = 0; i < _table.size(); i++) {
					Node* cur = _table[i];
					while (cur) {
						Node* next = cur->_next;
						size_t index = hf(cur->_kv.first) % newBucket.size();
						cur->_next = newBucket[index];
						newBucket[index] = cur;

						cur = next;
					}
					_table[i] = nullptr;
				}
				_table.swap(newBucket);
			}
			
			size_t index = hf(kv.first) % _table.size();
			Node* newNode = new Node(kv);
			newNode->_next = _table[index];
			_table[index] = newNode;
			_n++;
			return true;
		}
	private:
		vector<Node*> _table;
		size_t _n;
	};
	void test() {
		int a[] = { 4,24,14,7,37,27,57,67,34,14,54 };
		HashBucket<int, int> ht;
		for (auto e : a) {
			ht.Insert(make_pair(e, e));
		}
		ht.Insert(make_pair(84, 84));
	}
}

unordered_map和unordered_set模拟

对开散列的哈希表改造

1、将hashNode中存放的数据类型改为泛型

template<class T>
	struct HashNode {
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			,_next(nullptr)
		{}
	};

2、对哈希表增加迭代器

typedef __htIterator<K, T, T&, T*, KeyOfT, HashFunc> iterator;



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

具体增加的迭代器类如下：

template<class K,class T,class Ref, class Ptr,class KeyOfT,class HashFunc>
	struct __htIterator {
		typedef HashNode<T> Node;
		typedef __htIterator<K, T, Ref, Ptr, KeyOfT, HashFunc> self;

        //迭代器的成员变量
		Node* _node;
		HashBucket<K, T, KeyOfT, HashFunc>* _pht;

		__htIterator(Node* node,HashBucket<K,T,KeyOfT,HashFunc>* pht)
			:_node(node)
			,_pht(pht)
		{}
		Ref operator*() {
			return _node->_data;
		}
		Ptr operator->() {
			return &_node->_data;
		}
		self& operator++() {
			if (_node->_next) {
				_node = _node->_next;
			}
			else {
				KeyOfT kot;
				HashFunc hf;
				size_t index = hf(kot(_node->_data)) % _pht->_table.size();
				index++;
				//找到下一个不为空的桶
				while (index < _pht->_table.size()) {
					if (_pht->_table[index])
						break;
					else
						index++;
				}
				if (index == _pht->_table.size())
					_node = nullptr;
				else
					_node = _pht->_table[index];
			}
			return *this;
		}
		bool operator==(const self& s) const {
			return _node == s._node;
		}
		bool operator!=(const self& s) const {
			return _node != s._node;
		}
	};

3、对insert的返回值进行修改，改为pair<iterator,bool>，方便后续的unordered_map实现operator[]的实现。

pair<iterator,bool> Insert(const T& data)

4、对闭散列增加默认构造、拷贝函数、赋值和以及析构函数

HashBucket() = default;
		HashBucket(const self& hb) {
			_table.resize(hb._table.size());
			for (size_t i = 0; i < hb._table.size(); i++) {
				Node* cur = hb._table[i];
				while (cur) {
					Node* copy = new Node(cur->_data);
					copy->_next = _table[i];
					_table[i] = copy;

					cur = cur->_next;
				}
			}
		}

		self& operator=(self hb) {
			swap(_n, hb._n);
			_table.swap(hb._table);
			return *this;
		}
		~HashBucket() {
			for (size_t i = 0; i < _table.size(); i++) {
				Node* cur = _table[i];
				while (cur) {
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
		}

完整的改造代码如下:

namespace openHash {
	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 HashFunc>
	class HashBucket;

	template<class K,class T,class Ref, class Ptr,class KeyOfT,class HashFunc>
	struct __htIterator {
		typedef HashNode<T> Node;
		typedef __htIterator<K, T, Ref, Ptr, KeyOfT, HashFunc> self;

		Node* _node;
		HashBucket<K, T, KeyOfT, HashFunc>* _pht;

		__htIterator(Node* node,HashBucket<K,T,KeyOfT,HashFunc>* pht)
			:_node(node)
			,_pht(pht)
		{}
		Ref operator*() {
			return _node->_data;
		}
		Ptr operator->() {
			return &_node->_data;
		}
		self& operator++() {
			if (_node->_next) {
				_node = _node->_next;
			}
			else {
				KeyOfT kot;
				HashFunc hf;
				size_t index = hf(kot(_node->_data)) % _pht->_table.size();
				index++;
				//找到下一个不为空的桶
				while (index < _pht->_table.size()) {
					if (_pht->_table[index])
						break;
					else
						index++;
				}
				if (index == _pht->_table.size())
					_node = nullptr;
				else
					_node = _pht->_table[index];
			}
			return *this;
		}
		bool operator==(const self& s) const {
			return _node == s._node;
		}
		bool operator!=(const self& s) const {
			return _node != s._node;
		}
	};

	template<class K,class T,class KeyOfT,class HashFunc>
	class HashBucket {
		typedef HashNode<T> Node;

		template<class K, class T, class Ref, class Ptr, class KeyOfT, class HashFunc>
		friend struct __htIterator;

		typedef HashBucket<K, T, KeyOfT, HashFunc> self;
	public:
		typedef __htIterator<K, T, T&, T*, KeyOfT, HashFunc> iterator;

		/*HashBucket() {

		}*/

		HashBucket() = default;
		HashBucket(const self& hb) {
			_table.resize(hb._table.size());
			for (size_t i = 0; i < hb._table.size(); i++) {
				Node* cur = hb._table[i];
				while (cur) {
					Node* copy = new Node(cur->_data);
					copy->_next = _table[i];
					_table[i] = copy;

					cur = cur->_next;
				}
			}
		}

		self& operator=(self hb) {
			swap(_n, hb._n);
			_table.swap(hb._table);
			return *this;
		}
		~HashBucket() {
			for (size_t i = 0; i < _table.size(); i++) {
				Node* cur = _table[i];
				while (cur) {
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
		}
		iterator begin() {
			for (size_t i = 0; i < _table.size(); i++) {
				if (_table[i])
					return iterator(_table[i], this);
			}
			return end();
		}
		iterator end() {
			return iterator(nullptr, this);
		}
		bool Erase(const K& key) {
			if (_table.empty())
				return false;
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			Node* prev = nullptr;
			KeyOfT kot;
			while (cur) {
				if (kot(cur->_data) == key) {
					if (prev == nullptr)
						_table[index] = cur->_next;
					else
						prev->_next = cur->_next;
					delete cur;
					_n--;
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}
		iterator Find(const K& key) {
			if (_table.empty())
				return end();
			HashFunc hf;
			size_t index = hf(key) % _table.size();
			Node* cur = _table[index];
			KeyOfT kot;
			while (cur) {
				if (kot(cur->_data) == key)
					return iterator(cur, this);
				cur = cur->_next;
			}
			return end();
		}
		pair<iterator,bool> Insert(const T& data) {
			KeyOfT kot;
			iterator ret = Find(kot(data));
			if (ret != end())
				return make_pair(ret, false);
			HashFunc hf;
			
			if (_n == _table.size()) {
				//扩容
				size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
				vector<Node*> newBucket;
				newBucket.resize(newSize);
				for (size_t i = 0; i < _table.size(); i++) {
					Node* cur = _table[i];
					while (cur) {
						Node* next = cur->_next;
						size_t index = hf(kot(cur->_data)) % newBucket.size();
						cur->_next = newBucket[index];
						newBucket[index] = cur;

						cur = next;
					}
					_table[i] = nullptr;
				}
				_table.swap(newBucket);
			}
			
			size_t index = hf(kot(data)) % _table.size();
			Node* newNode = new Node(data);
			newNode->_next = _table[index];
			_table[index] = newNode;
			_n++;
			return make_pair(iterator(newNode, this), true);
		}
	private:
		vector<Node*> _table;
		size_t _n = 0;
	};
}

unordered_set模拟

unordered_set的底层使用的就是我们改造的开散列哈希表，因为改造的时候将hashnode中存放的数据改为了泛型，所以需要我们传入一个仿函数（这里我们传入的是SetKeyOfT这个函数），让哈希表拿到unordered_set的key，进行后续的逻辑操作。

除了SetKeyOfT这个仿函数，我们还需要另一个仿函数，即hash = Hash<K>，这个仿函数的作用是当我们通过SetKeyOfT拿到hashnode中的数据中的key值之后，将key的值转换成能够取模的整形。

#pragma once
#include "HTable.h"

namespace hzp {
	template<class K, class hash = Hash<K>>
	class My_Unordered_Set {
		struct SetKeyOfT {
			const K& operator()(const K& key) {
				return key;
			}
		};
	public:
		typedef typename openHash::HashBucket<K, K, SetKeyOfT, hash>::iterator iterator;
		iterator begin() {
			return _hb.begin();
		}
		iterator end() {
			return _hb.end();
		}
		pair<iterator, bool> insert(const K& key) {
			return _hb.Insert(key);
		}
	private:
		openHash::HashBucket<K, K, SetKeyOfT, hash> _hb;
	};
	void test_set() {
		My_Unordered_Set<int> mus;
		int a[] = { 4,14,34,7,24,17 };
		for (auto e : a)
			mus.insert(e);

		My_Unordered_Set<int>::iterator it = mus.begin();
		while (it != mus.end()) {
			cout << *it << " ";
			++it;
		}
		cout << endl;

		My_Unordered_Set<string> uss;
		uss.insert("sort");
		uss.insert("hash");
	}
}

unordered_map模拟

unordered_map的模拟与unordered_set的模拟极为相似，底层也是使用的改造的开散列的哈希表。请参考unordered_set的模拟读下边的代码。

#pragma once
#include "HTable.h"

namespace hzp {
	template<class K, class V, class hash = Hash<K>>
	class My_Unordered_Map {
		struct MapKeyOfT {
			const K& operator()(const pair<K,V>& key) {
				return key.first;
			}
		};
	public:
		typedef typename openHash::HashBucket<K, pair<K, V>, MapKeyOfT, hash>::iterator iterator;
		iterator begin() {
			return hb.begin();
		}
		iterator end() {
			return hb.end();
		}
		V& operator[](const K& key) {
			auto ret = hb.Insert(make_pair(key, V()));
			return ret.first->second;
		}
		pair<iterator,bool> insert(const pair<K, V>& kv) {
			return hb.Insert(kv);
		}

	private:
		openHash::HashBucket<K, pair<K, V>, MapKeyOfT, hash> hb;
	};
	void test_map() {
		My_Unordered_Map<string, string> dict;
		dict.insert(make_pair("sort", "排序"));
		dict.insert(make_pair("string", "ַ字符串"));
		dict.insert(make_pair("map", "地图"));

		dict["sort"] = "排序1";
		cout << dict["sort"] << endl;
		My_Unordered_Map<string, string>::iterator it = dict.begin();
		while (it != dict.end())
		{
			cout << it->first << ":" << it->second << endl;
			++it;
		}
		cout << endl;

		My_Unordered_Map<string, string> copy(dict);
		for (auto& e : copy) {
			cout << e.first << ":" << e.second << endl;
		}
	}
}

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

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

相关文章

当下的程序员该如何面对复杂的就业坏境

当下的程序员该如何面对复杂的就业坏境

已经2023年了&#xff0c;我们都知道现在开发趋向于年轻化&#xff0c;大部分都是90后、95后&#xff0c;毕竟&#xff0c;软件开发不像硬件开发一样&#xff0c;年限越高&#xff0c;相对来说越吃香。 31岁,前端工程师&#xff0c;工作经历8年&#xff0c;7年左右都在外包公司…
阅读更多...
LAMP架构（Apache、Mysql、PHP服务的部署）

LAMP架构（Apache、Mysql、PHP服务的部署）

目录 一、LAMP架构 1.LAMP组件 二、编译安装Apache httpd服务 1.关闭防火墙&#xff0c;拉取软件包 2.安装环境依赖包 3.配置软件模块 4.编译及安装 5.优化配置文件路径 6.添加httpd系统服务 7.修改httpd 服务配置文件 8.浏览器访问验证 三、编译安装mysqld服务 1.…
阅读更多...
java.lang.IllegalStateException: Failed to load ApplicationContext

java.lang.IllegalStateException: Failed to load ApplicationContext

问题描述 mvn clean install的时候报的如下异常&#xff1a; 紧接着又往下翻了一下日志还有一个这个错误 按正常来说通过可以取pom当中的properties标签的值呀。但是可以发现编译过后的application当中的值并没有被替换。 解决过程 &#xff08;1&#xff09;我先是将server.…
阅读更多...
1:400 万中国土壤数据介绍

1:400 万中国土壤数据介绍

一、土壤数据在科研以及日常生产生活中具有重要性价值。以下是其主要方面&#xff1a; 农业生产&#xff1a;土壤数据对于农业生产至关重要。通过了解土壤的物理、化学和生物学特性&#xff0c;农民可以合理管理土壤&#xff0c;选择适合的作物和肥料&#xff0c;调整灌溉和排水…
阅读更多...
yolov8_track追踪加分割（yolo目标检测+追踪+分割）

yolov8_track追踪加分割（yolo目标检测+追踪+分割）

**这个仓库包含了最先进的多目标追踪器。其中一些基于运动信息，另一些则基于运动和外观描述。对于后者，最先进的ReID模型也会自动下载。目前支持的模型有：DeepOCSORT LightMBN、BoTSORT LightMBN、StrongSORT LightMBN、OCSORT和ByteTrack。 我们提供了如何将这个包与流行的…
阅读更多...
【轻量化网络系列（4）】ShuffleNetV1论文超详细解读（翻译 ＋学习笔记+代码实现）

【轻量化网络系列（4）】ShuffleNetV1论文超详细解读（翻译 ＋学习笔记+代码实现）

前言 前面我们学了MobileNetV1-3&#xff0c;从这篇开始我们学习ShuffleNet系列。ShuffleNet是Face&#xff08;旷视&#xff09;在2017年发布的一个高效率可以运行在手机等移动设备的网络结构&#xff0c;论文发表在CVRP2018上。这个新的轻量级网络使用了两个新的操作&#…
阅读更多...
软考A计划-试题模拟含答案解析-卷一

软考A计划-试题模拟含答案解析-卷一

点击跳转专栏>Unity3D特效百例点击跳转专栏>案例项目实战源码点击跳转专栏>游戏脚本-辅助自动化点击跳转专栏>Android控件全解手册点击跳转专栏>Scratch编程案例 &#x1f449;关于作者 专注于Android/Unity和各种游戏开发技巧&#xff0c;以及各种资源分享&am…
阅读更多...
wait，notify，notifyAll，sleep，join等线程方法的全方位演练

wait，notify，notifyAll，sleep，join等线程方法的全方位演练

一、概念解释 1. 进入阻塞&#xff1a; 有时我们想让一个线程或多个线程暂时去休息一下&#xff0c;可以使用 wait()&#xff0c;使线程进入到阻塞状态&#xff0c;等到后面用到它时&#xff0c;再使用notify()、notifyAll() 唤醒它&#xff0c;线程被唤醒后&#xff0c;会等…
阅读更多...
网络规划与设计实验+配置案例报告+pkt

网络规划与设计实验+配置案例报告+pkt

目录 第一部分&#xff1a;网络规划与设计实验..... 7 实验一 用户需求分析报告的撰写... 7 一、实验目的和要求... 7 二、实验内容... 7 三、实验步骤... 7 3.1 项目背景... 7 3.1.1 信息化发展趋势... 7 3.1.2 学校基本情况介绍... 8 3.1.3 学校对网络建设的基本要求…
阅读更多...
Ovirt 开源虚拟化平台安装

Ovirt 开源虚拟化平台安装

ovirt官网 一、资源规划介绍 1.1、服务规划 ovirt版本 ovirt engine 4.3.10 ovirt node 4.3.10 ovirt.node01.opsvv.com 负责托管引擎服务 1.2、资源划分 1.2.1、节点划分 密码均为&#xff1a;12345678 Node02无法开启虚拟化&#xff0c;只演示加入集群节点使用 节点…
阅读更多...
NodeJs服务链路追踪日志

NodeJs服务链路追踪日志

&#xff08;逆境给人宝贵的磨炼机会。仅有经得起环境考验的人&#xff0c;才能算是真正的强者。自古以来的伟人&#xff0c;大多是抱着不屈不挠的精神&#xff0c;从逆境中挣扎奋斗过来的。——松下幸之助&#xff09; 服务链路追踪 服务的链路追踪指我们可以通过一个标记&am…
阅读更多...
阿里云ECS部署Trojan代理

阿里云ECS部署Trojan代理

项目地址&#xff1a;GitHub - Jrohy/trojan: trojan多用户管理部署程序, 支持web页面管理 一、容器部署&#xff1a; docker run --name trojan-mariadb --restartalways -p 3306:3306 -v /home/mariadb:/var/lib/mysql -e MYSQL_ROOT_PASSWORDtrojan -e MYSQL_ROOT_HOST% -e…
阅读更多...
在滴滴和字节跳动干了 2 年，太真实…

在滴滴和字节跳动干了 2 年，太真实…

先简单交代一下背景吧&#xff0c;某不知名985的本硕&#xff0c;17年毕业加入滴滴&#xff0c;之后跳槽到了头条&#xff0c;一直从事软件测试相关的工作。之前没有实习经历&#xff0c;算是两年半的工作经验吧。 这两年半之间完成了一次晋升&#xff0c;换了一家公司&#x…
阅读更多...
Linux 软件安装及vim详细用法和配置

Linux 软件安装及vim详细用法和配置

文章目录 一、Linux下的软件1、什么是软件包&#xff1f;2、软件安装的三种方法3、yum 安装 lrzsz软件&#xff08;windows和Linux消息互传&#xff09;4、深入理解yum源 二、 L i n u x 编辑器 − v i m 使用 Linux编辑器-vim使用 Linux编辑器−vim使用1、vim三种模式作用及其…
阅读更多...
递归之谜：解析无限嵌套的美

递归之谜：解析无限嵌套的美

一、前言 嵌套是指在一个事物中包含另一个事物&#xff0c;而递归是一种特殊形式的嵌套&#xff0c;其中一个事物包含自身。 递归就是一种嵌套的形式&#xff0c;递归函数解决问题时嵌套调用自身。递归的核心思想是通过反复应用相同的过程来解决问题&#xff0c;每一次调用都…
阅读更多...
容器化：MongoDB

容器化：MongoDB

1 缘起 开启容器化之路。 2 容器化MongDB 2.1 查看镜像 docker search mongodb2.2 安装 前台安装 sudo docker run \ --name mongodb \ -p 27017:27017 \ -v /home/xindaqi/mongodb/conf:/data/configdb \ -v /home/xindaqi/data/mongodb-data:/data/db \ -v /home/xind…
阅读更多...
99年表示真干不过，部门新来的00后测试员已把我卷崩溃，想离职了...

99年表示真干不过，部门新来的00后测试员已把我卷崩溃，想离职了...

在程序员职场上&#xff0c;什么样的人最让人反感呢? 是技术不好的人吗?并不是。技术不好的同事&#xff0c;我们可以帮他。 是技术太强的人吗?也不是。技术很强的同事&#xff0c;可遇不可求&#xff0c;向他学习还来不及呢。 真正让人反感的&#xff0c;是技术平平&#x…
阅读更多...
常见的GPIO口框架分析

常见的GPIO口框架分析

目录 1、单片机平台 2、嵌入式 Linux 平台 GPIO 八种工作模式详解 接着上一篇的讲&#xff0c;我们上一篇研究了 GPIO 的硬件结构&#xff0c;其来源于 STM32 官方手册&#xff0c;研究了 GPIO 的八种工作模式和推挽输出及开漏输出原理&#xff0c;接下来我们研究 GPIO 的软件…
阅读更多...
孙燕姿谈“AI孙燕姿”：她的反应让人意外，深入体验揭示其背后的真相与潜力！

孙燕姿谈“AI孙燕姿”：她的反应让人意外，深入体验揭示其背后的真相与潜力！

目录 前言AI歌手简介AI歌手的技术原理孙燕姿对“AI孙燕姿”的看法结论个人感受一、你听过AI歌手的音乐呈现吗&#xff1f;作为听众你的感受如何&#xff1f;二、你认为这种新型演艺模式能否获得广泛的市场认可&#xff1f;原因是什么&#xff1f;三、你认为AI歌手会取代流行歌手…
阅读更多...
SQL查询语言(3) 嵌套查询

SQL查询语言(3) 嵌套查询

如果不进行去重可能会出现一个情况 嵌套查询根据子查询的结果是否依赖于外层循环,分成相关子查询和不相关子查询 分类 IN 笔者总结&#xff1a;一般这种方法适用于查找有共性的元组&#xff0c;同一类事物比如查找和elsa选修相同科目的学生/选修相同科目的女同学。在后面我…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023