【C++杂货铺】unordered系列容器


目录

🌈 前言🌈

📁 unordered系列关联式容器

📁 底层结构

 📂 哈希概念

 📂 哈希冲突

 📂 哈希函数

  📂 哈希冲突解决

📁 模拟实现

📁 总结


🌈 前言🌈

        欢迎收看本期【C++杂货铺】,本期内容将讲解C++的STL中的unordered系列容器,其中包含了unordered_map 和 unordered_set 的使用,底层结构哈希的原理,实现,最后模拟实现unordered系列的容器。

📁 unordered系列关联式容器

        在C++98中,STL提供了底层为红黑树结构的系列关联式容器,在查询时效率可达到 O(log2),即最差情况下需要比较红黑树的高度次,当书中的节点比较多时,查询效率也不理想。

        最好的查询是,进行很少的比较次数就能将元素找到,因此在C++11中,STL又提供了4个unordered系列的关联式容器,这四个容器与红黑树结构的关联式容器使用方式基本类似,只是底层结构不同,本文中只对unordered_map 和 unordered_set进行介绍。

        其中,unordered_map是存储 <key , value>键值对的关联式容器,其允许通过key快速的索引找到对应的value。

📁 底层结构

        unordered系列的关联式容器效率之所以比较高,是因为底层使用了哈希结构。

 📂 哈希概念

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

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

        该结构中:

        ● 插入元素:根据插入元素的关键码,用哈希函数计算出该元素的存储位置并按次位置进行存放。

        ● 搜搜元素:对元素的关键码进行同样的计算,把求得的函数值当做元素的存储位置,在结构中按次位置取元素的比较,若关键码相等,则搜索成功。

        该方式即为哈希(散列)方法,哈希方法中使用的转换函数称为哈希(散列)函数,构造出的结构为哈希表(散列表)。

        该方法不必经过多次关键码的比较,因此搜索的速度比较快。

 📂 哈希冲突

        当两个数据元素的关键码 i != j , 但是Hash(i) == Hash(j),即:不同关键码通过相同的哈希函数计算出相同的哈希地址,这种现象成为哈希冲突(哈希碰撞)。

 📂 哈希函数

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

        哈希函数的设计原则:        

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

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

        3. 哈希函数应比较简单。

        常见的哈希函数:

        1. 直接定址法(常用)

         取关键字的某个线性函数为散列地址:Hash(key) = A*Key + B。

         优点:简单,均匀

         缺点:需要实现知道关键字的分布情况

         使用场景:适合查找比较小且连续的情况

        2. 除留余数法(常用)

         设散列表允许的地址数为m,取一个不大于m,但是接近或等于m的质数p作为除数,按照哈希函数:Hash(key) = key % p (p <= m) ,将关键字改为哈希地址。

        3. 平方取中法

        假设关键字为1234,对它平方就是1522756,抽取中间的3位227作为哈希地址;

        再比如关键字为4321,对它平方就是18671041,抽取中间的3位671(或710)作为哈希地址

        平方取中法比较适合:不知道关键字的分布,而位数又不是很大的情况

         4. 折叠法(了解)

        折叠法是将关键字从左到右分割成位数相等的几部分(最后一部分位数可以短些),然后将这 几部分叠加求和,并按散列表表长,取后几位作为散列地址。

        折叠法适合事先不需要知道关键字的分布,适合关键字位数比较多的情况

        5. 随机数法(了解)

        选择一个随机函数,取关键字的随机函数值为它的哈希地址,即H(key) = random(key),其中 random为随机数函数。

        通常应用于关键字长度不等时采用此法。

        6. 数学分析法(了解)

        设有n个d位数,每一位可能有r种不同的符号,这r种不同的符号在各位上出现的频率不一定 相同,可能在某些位上分布比较均匀,每种符号出现的机会均等,在某些位上分布不均匀只 有某几种符号经常出现。可根据散列表的大小,选择其中各种符号分布均匀的若干位作为散 列地址。例如:

        假设要存储某家公司员工登记表,如果用手机号作为关键字,那么极有可能前7位都是 相同 的,那么我们可以选择后面的四位作为散列地址,如果这样的抽取工作还容易出现 冲突,还 可以对抽取出来的数字进行反转(如1234改成4321)、右环位移(如1234改成4123)、左环移 位、前两数与后两数叠加(如1234改成12+34=46)等方法。

        数字分析法通常适合处理关键字位数比较大的情况,如果事先知道关键字的分布且关键字的 若干位分布较均匀的情况

        注意:哈希函数设计的越精妙,产生哈希冲突的可能性就越低,但是无法避免哈希冲突

  📂 哈希冲突解决

1. 闭散列

        闭散列也叫做开放定址法,当发生哈希冲突时,如果哈希表未被填满,说明在哈希表中必然还有空位置,那么可以吧key存放到冲突位置的“下一个”空位置中区。那么如果寻找下一个空位置呢?

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

        插入:

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

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

        删除:

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

// 哈希表每个空间给个标记
// EMPTY此位置空, EXIST此位置已经有元素, DELETE元素已经删除
enum State{EMPTY, EXIST, DELETE};
// 注意:假如实现的哈希表中元素唯一,即key相同的元素不再进行插入
// 为了实现简单,此哈希表中我们将比较直接与元素绑定在一起
template<class K, class V>
class HashTable
{
    struct Elem
   {   
        pair<K, V> _val;
        State _state;
   };
    
public:
    HashTable(size_t capacity = 3)
       : _ht(capacity), _size(0)
   {
        for(size_t i = 0; i < capacity; ++i)
            _ht[i]._state = EMPTY;
   }
    
   bool Insert(const pair<K, V>& val)
   {
       // 检测哈希表底层空间是否充足
       // _CheckCapacity();
       size_t hashAddr = HashFunc(key);
       // size_t startAddr = hashAddr;
       while(_ht[hashAddr]._state != EMPTY)
       {
           if(_ht[hashAddr]._state == EXIST && _ht[hashAddr]._val.first 
== key)
               return false;
           
           hashAddr++;
           if(hashAddr == _ht.capacity())
               hashAddr = 0;
           /*
           // 转一圈也没有找到,注意:动态哈希表,该种情况可以不用考虑,哈希表中元
素个数到达一定的数量,哈希冲突概率会增大,需要扩容来降低哈希冲突,因此哈希表中元素是
不会存满的
           if(hashAddr == startAddr)
               return false;
           */
       }
       
       // 插入元素
       _ht[hashAddr]._state = EXIST;
       _ht[hashAddr]._val = val;
       _size++;
       return true;
   }
   int Find(const K& key)
   {
       size_t hashAddr = HashFunc(key);
       while(_ht[hashAddr]._state != EMPTY)
       {
           if(_ht[hashAddr]._state == EXIST && _ht[hashAddr]._val.first 
== key)
               return hashAddr;
           
           hashAddr++;
       }
       return hashAddr;
   }
   bool Erase(const K& key)
   {
       int index = Find(key);
       if(-1 != index)
       {
           _ht[index]._state = DELETE;
           _size++;
           return true;
       }
       return false;
   }
   size_t Size()const;
   bool Empty() const;    
   void Swap(HashTable<K, V, HF>& ht);
private:
    size_t HashFunc(const K& key)
   {
        return key % _ht.capacity();
   }
private:
    vector<Elem> _ht;
    size_t _size;
};

思考:哈希表什么情况下进行扩容?如何扩容?

void CheckCapacity()
{
    if(_size * 10 / _ht.capacity() >= 7)
   {
        HashTable<K, V, HF> newHt(GetNextPrime(ht.capacity));
        for(size_t i = 0; i < _ht.capacity(); ++i)
       {
            if(_ht[i]._state == EXIST)
                newHt.Insert(_ht[i]._val);
       }
        
        Swap(newHt);
   }
}

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

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

        1.2 二次探测

        线性探测的缺陷是产生冲突的数据堆积在一起,这与其找下一个空位置有关系,因为找空位置的方式就是挨着往后逐个去找,因此二次探测是为了避免该问题。

        找到下一个空位置的方法为:H(i) = (k + i^2) % m 或者 H(i) = (k - i^2) % m,其中i = 1,2,3..,k是通过哈希函数,对元素键值key进行计算得到的地址,m是表的大小。

        研究表明:当表的长度为质数且表装载因子a不超过0.5时,新的表项一定能够插入,而且任 何一个位置都不会被探查两次。因此只要表中有一半的空位置,就不会存在表满的问题。在 搜索时可以不考虑表装满的情况,但在插入时必须确保表的装载因子a不超过0.5,如果超出 必须考虑增容。

        因此,闭散列最大的缺陷就是空间利用率较低,这也是哈希的缺陷。

2. 开散列

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

template<class V>
struct HashBucketNode
{
    HashBucketNode(const V& data)
       : _pNext(nullptr), _data(data)
   {}
    HashBucketNode<V>* _pNext;
    V _data;
};
// 本文所实现的哈希桶中key是唯一的
template<class V>
class HashBucket
{
    typedef HashBucketNode<V> Node;
    typedef Node* PNode;
public:
    HashBucket(size_t capacity = 3): _size(0)
   { _ht.resize(GetNextPrime(capacity), nullptr);}
    
    // 哈希桶中的元素不能重复
    PNode* Insert(const V& data)
   {
        // 确认是否需要扩容。。。        // _CheckCapacity();
        
        // 1. 计算元素所在的桶号
        size_t bucketNo = HashFunc(data);
        
        // 2. 检测该元素是否在桶中
        PNode pCur = _ht[bucketNo];
        while(pCur)
       {
            if(pCur->_data == data)
                return pCur;
            
            pCur = pCur->_pNext;
       }
        
        // 3. 插入新元素
        pCur = new Node(data);
        pCur->_pNext = _ht[bucketNo];
        _ht[bucketNo] = pCur;
        _size++;
        return pCur;
   }
     
    // 删除哈希桶中为data的元素(data不会重复),返回删除元素的下一个节点
    PNode* Erase(const V& data)
   {
        size_t bucketNo = HashFunc(data);
        PNode pCur = _ht[bucketNo];
        PNode pPrev = nullptr, pRet = nullptr;
        
        while(pCur)
       {
            if(pCur->_data == data)
           {
                if(pCur == _ht[bucketNo])
                    _ht[bucketNo] = pCur->_pNext;
                else
                    pPrev->_pNext = pCur->_pNext;
                
                pRet = pCur->_pNext;
                delete pCur;
                _size--;
                return pRet;
           }
       }
        
        return nullptr;
   }
    
    PNode* Find(const V& data);
    size_t Size()const;
    bool Empty()const;
    void Clear();
    bool BucketCount()const;
    void Swap(HashBucket<V, HF>& ht;
    ~HashBucket();
private:
    size_t HashFunc(const V& data)
   {
        return data%_ht.capacity();
   }
private:
    vector<PNode*> _ht;
    size_t _size;      // 哈希表中有效元素的个数
};

开散列增容:

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

void _CheckCapacity()
{
    size_t bucketCount = BucketCount();
    if(_size == bucketCount)
   {
        HashBucket<V, HF> newHt(bucketCount);
        for(size_t bucketIdx = 0; bucketIdx < bucketCount; ++bucketIdx)
       {
            PNode pCur = _ht[bucketIdx];
            while(pCur)
           {
                // 将该节点从原哈希表中拆出来
                _ht[bucketIdx] = pCur->_pNext;
                
                // 将该节点插入到新哈希表中
                size_t bucketNo = newHt.HashFunc(pCur->_data);
                pCur->_pNext = newHt._ht[bucketNo];
                newHt._ht[bucketNo] = pCur;
                pCur = _ht[bucketIdx];
           }
       }
        
        newHt._size = _size;
        this->Swap(newHt);
   }
}

📁 模拟实现

1. 模拟实现哈希表

template<class T>
struct HashNode
{
	HashNode()
	{}

	HashNode(const T& data)
		:_data(data)
		, _next(nullptr)
	{}

	T _data;
	HashNode* _next;
};

template<class K,class T,class KOfT ,class Hash=HashFunc<K>>
class HashTable
{
	typedef HashNode<T> Node;

public:

	template<class Ptr,class Ref>
	struct HashTableIterator
	{
		typedef HashNode<T> Node;

		typedef HashTableIterator Self;
			

		Node* _node = nullptr;
		const HashTable* _pht;

		HashTableIterator(Node* node, const HashTable* pht)
			:_node(node)
			, _pht(pht)
		{}
	
		Self& operator++()
		{
			KOfT kot;
			Hash hs;

			if (_node->_next == nullptr)
			{
				size_t hashi = hs(kot(_node->_data)) % _pht->_tables.size();
				hashi++;
				for (; hashi < _pht->_tables.size();hashi++)
				{
					if (_pht->_tables[hashi] != nullptr)
					{
						break;
					}
				}
				if (hashi == _pht->_tables.size())
				{
					_node = nullptr;
				}
				else
				{
					_node = _pht->_tables[hashi];
				}
			}
			else
			{
				_node = _node->_next;
			}

			return *this;
		}

		Ref operator*()
		{
			return _node->_data;
		}

		Ptr operator->()
		{
			return &_node->_data;
		}

		bool operator!=(const Self& it)
		{
			return _node != it._node;
		}

	};

	typedef HashTableIterator<T*, T&> Iterator;
	typedef HashTableIterator<const T*, const T&> const_Iterator;

	HashTable()
	{
		_tables.resize(10,nullptr);
		_n = 0;
	}

	Iterator Begin()
	{
		//this -> HT*

		Node* cur = nullptr;
		for (int i = 0; i < _tables.size();i++)
		{
			if (_tables[i])
			{
				cur = _tables[i];
				break;
			}
		}
		return Iterator(cur, this);
	}

	Iterator End()
	{
		//this -> HT*

		return Iterator(nullptr,this);
	}

	const_Iterator Begin() const
	{
		//this -> const HT*

		Node* cur = nullptr;
		for (int i = 0; i < _tables.size();i++)
		{
			if (_tables[i])
			{
				cur = _tables[i];
				break;
			}
		}
		return const_Iterator(cur, this);
	}

	const_Iterator End() const
	{
		//this -> const HT*
		return const_Iterator(nullptr, this);
	}


	Iterator Find(const K& k)
	{
		Hash hs;
		KOfT kot;

		size_t hashi = hs(k) % _tables.size();
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (kot(cur->_data) == k)
				return Iterator(cur, this);
			cur = cur->_next;
		}

		return Iterator(nullptr, this);
	}

	pair<Iterator,bool> Insert(const T& data)
	{
		Hash hs;
		KOfT kot;
		Iterator it = Find(kot(data));
		if (it != End())
			return make_pair(it, false);
			
		if (_n == _tables.size())
		{
			//扩容
			vector<Node*> newtables(_tables.size() * 2,nullptr);
			for (int i = 0; i < _tables.size(); i++)
			{
				if (_tables[i])
				{
					Node* cur = _tables[i];
					while (cur)
					{
						size_t hashi = hs(kot(cur->_data)) % newtables.size();

						Node* next = cur->_next;
						cur->_next = newtables[i];
						newtables[hashi] = cur;
						cur = next;
					}
				}
			}
			_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 make_pair(Iterator(_tables[hashi], this),true);
	}

	bool Erase(const K& k)
	{
		if (Find(k) == nullptr)
			return false;

		Hash hs;
		KOfT kot;

		size_t hashi = hs(k) % _tables.size();

		Node* prev = nullptr;
		Node* cur = _tables[hashi];
		while (cur)
		{
			if (kot(cur->_data) == k)
			{
				if (prev == nullptr)
				{
					_tables[hashi] = cur->_next;
				}
				else
				{
					prev->_next = cur->_next;
				}

				delete cur;
				break;
			}
			prev = cur;
			cur = cur->_next;
		}

		return true;
	}

private:
	vector<Node*> _tables;
	size_t _n = 0;
};

2. 模拟实现unordered_set

template<class K>
class unordered_set
{

	struct SetKOfT
	{
		K operator()(const K& key)
		{
			return key;
		}
	};

public:
	typedef typename hash_bucket::HashTable<K, K, SetKOfT>::Iterator iterator;
	typedef typename hash_bucket::HashTable<K, K, SetKOfT>::const_Iterator const_iterator;

	pair<iterator, bool> insert(const K& key)
	{
		return ht.Insert(key);
	}

	bool erase(const K& key)
	{
		return ht.Erase(key);
	}

	iterator find(const K& key)
	{
		return ht.Find(key);
	}

	iterator begin()
	{
		return ht.Begin();
	}

	iterator end()
	{
		return ht.End();
	}

	const_iterator begin() const
	{
		return ht.Begin();
	}

	const_iterator end() const
	{
		return ht.End();
	}

private:
	hash_bucket::HashTable<K, K,SetKOfT> ht;
};

3. 模拟实现unordered_map

template<class K, class V>
class unordered_map
{

	struct MapKOfT
	{
		K operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};

public:
	typedef typename hash_bucket::HashTable<K, pair<K, V>, MapKOfT>::Iterator iterator;
	typedef typename hash_bucket::HashTable<K, pair<K, V>, MapKOfT>::const_Iterator const_iterator;

	iterator insert(const pair<K, V>& kv)
	{
		return ht.Insert(kv);
	}

	bool erase(const K& key)
	{
		return ht.Erase(key);
	}

	iterator find(const K& key)
	{
		return ht.Find(key);
	}

	iterator begin()
	{
		return ht.Begin();
	}

	iterator end()
	{
		return ht.End();
	}

	const_iterator begin() const
	{
		return ht.Begin();
	}

	const_iterator end() const
	{
		return ht.End();
	}

	V& operator[](const K& key)
	{
		pair<iterator, bool> ret = ht.Insert(make_pair(key, V()));
		return ret.first->second;
	}

private:
	hash_bucket::HashTable<K, pair<K,V>,MapKOfT> ht;
};

📁 总结

        以上,就是本期内容,介绍了unordered_set 和 unordered_map是什么,底层的哈希表,什么是哈希,以及哈希实现快速查找的原理,通过某种哈希函数对关键字进行计算,得到地址。也讲解了如果不同值计算得到相同地址,即哈希冲突时,如何处理。

        最后,也给出了模拟实现哈希表,unordered_set 和 unordered_map的代码。

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

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

相关文章

Tailwindcss Layout布局相关样式及实战案例,5万字长文,附完整源码和效果截图

aspect 相关样式类 基础样式 ClassPropertiesaspect-autoaspect-ratio: auto;aspect-squareaspect-ratio: 1 / 1;aspect-videoaspect-ratio: 16 / 9; 案例&#xff1a;引入B站视频 Use the aspect-* utilities to set the desired aspect ratio of an element. 使用’ asp…

k8s学习--ConfigMap详细解释与应用

文章目录 一 什么是configmapConfigMap 的好处ConfigMap 的限制 二.创建ConfigMap的4种方式1.在命令行指定参数创建2.在命令行通过多个文件创建3.在命令行通过文件提供多个键值对创建4.YAML资源清单文件创建 三 configmap的两种使用方法1.通过环境变量的方式传递给pod2.通过vol…

Java(十二)---认识异常

文章目录 前言1. 异常的概念与体系结构1.1.异常的概念1.异常的体系1.3 异常的分类 2. 异常的处理2.1 防御式编程2.2 异常的抛出2.3 异常的捕获2.3.1 异常声明throws2.3.2 try-catch捕获并处理2.3.3 finally 2.4 异常的处理流程 3. 自定义异常类 前言 这一篇就是咱们学习JavaSE…

学习笔记——网络参考模型——TCP/IP模型(传输层)

四、TCP/IP模型-传输层 一、TCP 1、TCP定义 TCP(Transmission Control Protocol&#xff0c;传输控制协议)∶为应用程序提供可靠的面向连接的通信服务。目前&#xff0c;许多流行的应用程序都使用TCP。 连接&#xff1a;正式发送数据之前&#xff0c;提前建立好一种虚拟的&…

String常用操作

String常用方法 构造字符串 常用的构造字符串有3种&#xff1a; 1.直接赋值String s "abcd"; 2.实例化调用构造方法String s new String("abcd"); 3.实例化传字符数组 char[] ch {a,b,c,d}; String s new String(ch);字符串比较 比较 比较的是两个…

40.8K开源交流社区平台:Discourse

Discourse&#xff1a; 开放源代码&#xff0c;打造社区讨论的自由家园- 精选真开源&#xff0c;释放新价值。 概览 Discourse是一个完全开源的社区平台&#xff0c;为那些希望完全控制自己网站运行方式和地点的组织和个人提供服务。经过十多年的实战考验&#xff0c;Discours…

索引 ---- mysql

目录 1. 索引 1.1 概念 1.2 作用 1.3 使用场景 1.4 使用 1.4.1查看索引 1.4.2 创建索引 1.4.3 删除索引 1.5 注意事项 1.6 索引底层的数据结构 (面试经典问题) 1. 索引 1.1 概念 索引是一种特殊的文件&#xff0c;包含着对数据表里所有记录的引用指针。可以对表中的…

数据库(18)——DCL权限控制

MySQL常用权限 权限说明ALL,ALL PRIVILEGES所有权限SELECT查询数据INSERT插入数据UPDATE修改数据DELETE删除数据ALTER修改表DROP删除数据库/表/视图CREATE创建数据库/表 DCL语法 查询权限 SHOW GRANTS FOR 用户名主机名; 查询hello的权限 SHOW GRANTS FOR hellolocalhost; 授…

方法重写

自学python如何成为大佬(目录):https://blog.csdn.net/weixin_67859959/article/details/139049996?spm1001.2014.3001.5501 基类的成员都会被派生类继承&#xff0c;当基类中的某个方法不完全适用于派生类时&#xff0c;就需要在派生类中重写父类的这个方法&#xff0c;这和…

pycharm链接auto al服务器

研0提前进组&#xff0c;最近阻力需求是把一个大模型复现&#xff0c;笔者电脑18年老机子&#xff0c;无法满足相应的需求。因此租用auto dl服务器。本文记录自己使用pycharm&#xff08;专业版&#xff09;链接auto dl期间踩过的坑。 1.下载pycharm专业版 这一步不解释了&am…

ESP32 WSL环境搭建

克隆代码 代码链接&#xff1a;https://gitee.com/EspressifSystems/esp-idf 克隆代码&#xff1a; git clone https://gitee.com/EspressifSystems/esp-idf 安装环境 cd esp32 /usr/bin/python3 ./esp-idf/tools/idf_tools.py 这里可能需要安装比较久&#xff0c; 有些需要…

基于51单片机的俄罗斯方块

一.硬件方案 本设计采用STC89C52RC单片机作为系统的芯片&#xff0c;实现人机交互、娱乐等功能。选用LCD12864实现俄罗斯方块游戏界面、图形显示&#xff1b;选用独立按键实现游戏控制。本设计实现的基本功能是&#xff1a;用按键控制目标方块的变换与移动&#xff1b;消除一行…

Java 多线程创建:三种主要方法

多线程编程是Java中一个重要的技术点&#xff0c;它允许程序并行执行多个任务&#xff0c;从而提高程序的执行效率。本文将详细介绍在Java中创建多线程的三种主要方法&#xff1a;继承Thread类、实现Runnable接口以及使用Callable和Future接口。 1. 继承 Thread 类 继承Threa…

python_将二维列表转换成HTML格式_邮件相关

python_将二维列表转换成HTML_邮件相关 data[["理想","2"],["理想2","3"]]def list_to_html_table(data):"""将二维列表转换为HTML表格格式的字符串。参数:data -- 二维列表&#xff0c;表示表格的数据。返回:一个字符…

最新国内AI工具(ChatGPT4.0、GPTs、AI绘画、文档分析使用教程)

如何利用AI提高内容生产效率&#xff1f; AI&#xff08;人工智能&#xff09;正以惊人的速度改变我们的生活方式&#xff0c;尤其是在内容生产领域。作为一名创作者&#xff0c;你可能会发现自己在面对海量信息时无从下手&#xff0c;或者在紧迫的截止日期前感觉力不从心。这时…

汽车数据应用构想(二)

一直说数据价值场景&#xff0c;啥叫有价值&#xff1f;啥样的场景有价值&#xff1f;按互联网的价值观来看&#xff0c;用户的高频需求就是价值。用户也许不会付费&#xff0c;但只要他天天用&#xff0c;那就是流量&#xff0c;就是用户黏性&#xff0c;就是价值&#xff01;…

【Qt】对话框

文章目录 1 :peach:对话框介绍:peach:2 :peach:对话框的分类:peach:2.1 :apple:模态对话框:apple:2.2 :apple:非模态对话框:apple:2.3 :apple:混合属性对话框:apple: 3 :peach:Qt 内置对话框:peach:3.1 :apple:消息对话框 QMessageBox:apple: 1 &#x1f351;对话框介绍&#x…

【一刷《剑指Offer》】面试题 29:数组中出现次数超过一半的数字

力扣对应题目链接&#xff1a;169. 多数元素 - 力扣&#xff08;LeetCode&#xff09; 牛客对应题目链接&#xff1a;数组中出现次数超过一半的数字_牛客题霸_牛客网 (nowcoder.com) 核心考点 &#xff1a; 数组使用&#xff0c;简单算法的设计。 一、《剑指Offer》对应内容 二…

计算机网络学习实践:模拟PPP协议验证虚拟局域网(VLAN)

计算机网络实践&#xff1a;模拟PPP协议&&验证虚拟局域网&#xff08;VLAN&#xff09; 挺有意思的大家可以跟着做一做&#xff0c;我是跟着韩志刚老师的视频做的 https://www.bilibili.com/video/BV1Qr4y1N7cH?p31&vd_source7831c5b97cfc5c745eb48ff04f6515e7 …

GCB | 基于36年5个生态系统观测数据发现表层土壤深度提高生态系统的生产力和稳定性

陆地生态系统生产力对全球粮食安全和促进碳固存至关重要&#xff0c;但生产力受到气候变化以及火灾、干旱、洪水、霜冻频率增加和生物多样性减少的压力。了解控制生态系统初级生产力变异的不同因素和机制&#xff0c;为维持生态系统初级生产力和增强生态系统恢复力提供了科学依…