【哈希】闭散列的线性探测和开散列的哈希桶解决哈希冲突（C++两种方法模拟实现哈希表）（1）

图片名称
🎉博主首页： 有趣的中国人

🎉专栏首页： C++进阶

🎉其它专栏： C++初阶 | Linux | 初阶数据结构

在这里插入图片描述

小伙伴们大家好，本片文章将会讲解 哈希函数与哈希 之 闭散列的线性探测解决哈希冲突 的相关内容。

如果看到最后您觉得这篇文章写得不错，有所收获，麻烦点赞👍、收藏🌟、留下评论📝。您的支持是我最大的动力，让我们一起努力，共同成长！

文章目录

  • `1. 哈希概念`
  • `2. 哈希冲突`
  • `3. 解决哈希冲突的方法`
    • `3.1 线性探测的代码实现`
      • ==<font color = blue size = 5><b>⌛1、枚举类型定义状态⏳==
      • ==<font color = blue size = 5><b>⌛2、插入元素（Insert）⏳==
      • ==<font color = blue size = 5><b>⌛3、查找元素（Find）⏳==
      • ==<font color = blue size = 5><b>⌛4、删除元素（Erase）⏳==
  • `4. 字符串哈希`
    • `详谈字符串哈希的相关做法`
  • `5. 完整代码`


1. 哈希概念


⌛哈希函数的概念⏳

哈希函数是一种将输入数据（例如字符串、数字等）转换为固定长度的输出数据的函数。这个输出通常称为哈希值或哈希码。

哈希函数的特点是，对于相同的输入，它总是生成相同的输出，而且通常无法根据输出反推出输入。这种特性使得哈希函数在密码学、数据验证和数据检索等领域中非常有用。


⌛哈希表的概念⏳

哈希表是一种数据结构，它利用哈希函数来快速定位存储和检索数据。哈希表由一个数组组成，每个数组元素称为桶（ b u c k e t bucket bucket）或槽（ s l o t slot slot）。当需要存储数据时，哈希函数会将数据的键（ k e y key key）映射到数组中的一个位置，这个位置称为哈希值。数据被存储在这个位置对应的桶中。当需要检索数据时，哈希函数会根据键计算出哈希值，并在数组中定位到对应的桶，然后从这个桶中检索数据。

哈希表的关键之处在于，哈希函数的设计要尽可能地使得不同的键映射到不同的桶，以减少哈希冲突（多个键映射到同一个桶的情况）。但即使哈希函数设计得非常好，也无法完全避免冲突。因此，哈希表通常会使用一些方法来处理冲突，例如链表、开放寻址等。

链表法是将哈希表的每个桶设置为一个链表，当发生冲突时，将新数据添加到对应桶的链表中。开放寻址法则是在发生冲突时，顺序地寻找下一个空桶来存储数据。

哈希表的优点是能够以常量时间复杂度进行数据的插入、删除和查找操作，使得它在处理大量数据时具有高效性。常见的应用包括哈希集合、哈希映射等。


⌛哈希函数与哈希表的例子⏳


在这里插入图片描述

  • 上图哈希函数是 h a s h ( k e y ) = k e y hash(key) = key hash(key)=key % c a p a c i t y capacity capacity；
  • 通过哈希函数构造出的表称为哈希表。

2. 哈希冲突


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


⌛哈希冲突的例子⏳

在这里插入图片描述

  • 对于两个不同的输入数据 1 1 1 和 11 11 11，通过相同的哈希函数： h a s h ( k e y ) = k e y hash(key) = key hash(key)=key % c a p a c i t y capacity capacity；
  • 计算出来的结果是相同的，这就是哈希冲突。

3. 解决哈希冲突的方法


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


⌛闭散列的线性探测法⏳

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

  1. 线性探测

    比如下图中的场景，现在需要插入元素 44 44 44，先通过哈希函数计算哈希地址， h a s h A d d r hashAddr hashAddr为 4 4 4，因此 44 44 44 理论上应该插在该位置，但是该位置已经放了值为 4 4 4 的元素，即发生哈希冲突。

    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
    • 插入
      • 通过哈希函数获取待插入元素在哈希表中的位置
      • 如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，使用线性探测找到下一个空位置，插入新元素
        在这里插入图片描述
    • 删除

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

3.1 线性探测的代码实现

⌛1、枚举类型定义状态⏳


在实现删除的思路的时候思路如下：
  1. 根据哈希函数算出对应的哈希值；
  2. 以此位置为起始点，开始向后寻找；
  3. 如果找到与传入 k e y key key 值相等的值则查找成功；
  4. 如果查找到空还未找到，则查找失败。

但是这样删除可能会出现以下错误：

  1. 当出现哈希冲突的时候，我们尝试删除对应哈希值位置上的元素，没问题，但是删除之后再删除另一个元素时，哈希值会映射到此位置，但是此位置为空，会引发错误。
  2. 插入有哈希冲突的两个值（ v 1 和 v 2 v1和v2 v1和v2），插入第一个值的时候没问题，插入的位置为 l o c 1 loc1 loc1，假设此位置后面有一个元素 x x x ，在插入第二个元素的时候，会沿着顺序查找到为空的位置 l o c 2 loc2 loc2 。插入完成。
    • 如果此时我们要删除 x x x，那么此位置就变为空；
    • 接着删除 v 1 v1 v1，没问题；
    • 删除 v 2 v2 v2 的时候，就会出现问题。

因此我们需要有一个标记来记录每个节点的状态：

代码：

enum Status
{
	EXIST,
	DELETE,
	EMPTY
};

template<class K, class V>
struct HashData
{
	Status _status = EMPTY;
	pair<K, V> _kv;
};

⌛2、插入元素（Insert）⏳


插入元素思路：

  1. 根据哈希函数计算插入的位置；
  2. 如果此位置的状态不为存在，直接插入；
  3. 如果此位置的状态为存在，向后查找，找到第一个状态不等于存在（空或者删除）的位置，进行插入。

Insert代码(version 1)：

bool Insert(const pair<K, V>& kv)
{
	// 哈希函数计算位置
	size_t hashi = kv.first % _table.size();
	// 状态为存在就加加
	while (_table[hashi]._status == EXIST)
	{
		++hashi;
		hashi %= _table.size();
	}
	// 出循环说明找到状态不为存在的位置，进行插入
	_table[hashi]._kv = kv;
	_table[hashi]._status = EXIST;
	++_n;
	return true;
}

⌛2.1、负载因子（load_factor)⏳

我们可以思考一下什么时候进行扩容呢？

首先看一下负载因子的定义：

在这里插入图片描述

  • 负载因子： l o a d f a c t o r = n ÷ t a b l e . s i z e ( ) loadfactor = n ÷ table.size() loadfactor=n÷table.size()

我们这边控制：当负载因子超过 0.7 0.7 0.7 的时候进行扩容，扩容思路如下：

  1. 新定义一个HashTable的对象newht，开的空间大小为两倍的原始大小( n e w s i z e = 2 ∗ t a b l e . s i z e ( ) newsize = 2 * table.size() newsize=2∗table.size())；
  2. 遍历原始HashTable对象中的成员变量_table，如果状态为存在，则调用newht的Insert函数;
  3. 如果状态不为存在，则继续往后加加；
  4. 直到走到原始HashTable中的成员变量_table的_table.size()位置。
  5. 对两个_table进行交换：_table.swap(newht._table)；

扩容代码：

if (_n * 10 / _table.size() >= 7)
{
	// 新空间大小
	size_t newsize = 2 * _table.size();
	// 定义一个新对象
	HashTable<K, V, Func> newHT(newsize);
	for (size_t i = 0; i < _table.size(); ++i)
	{
		// 如果状态为存在则在新的对象中进行插入
		if (_table[i]._status == EXIST)
			newHT.Insert(_table[i]._kv);
	}
	// 交换两个表
	_table.swap(newHT._table);
}

Insert代码(version 2)：

bool Insert(const pair<K, V>& kv)
{
	if (_n * 10 / _table.size() >= 7)
	{
		size_t newsize = 2 * _table.size();
		HashTable<K, V, Func> newHT(newsize);
		for (size_t i = 0; i < _table.size(); ++i)
		{
			if (_table[i]._status == EXIST)
				newHT.Insert(_table[i]._kv);
		}
		_table.swap(newHT._table);
	}
	size_t hashi = kv.first % _table.size();
	while (_table[hashi]._status == EXIST)
	{
		++hashi;
		hashi %= _table.size();
	}
	_table[hashi]._kv = kv;
	_table[hashi]._status = EXIST;
	++_n;
	return true;
}

⌛3、查找元素（Find）⏳


查找元素的思路：

  1. 首先根据哈希函数计算出哈希值（映射位置）；
  2. 以此位置为起始点，向后寻找，直到找到为空的位置；
  3. 如果在此之间找到与所给的值相等的位置，返回此位置的地址；
    • 注意这里要判断一下找到的节点的状态是否为删除，如果是删除状态，那就直接跳过；
    • 如果不是删除才可以返回此节点的地址。
  4. 如果一直到空还未找到，说明没有哈希表中没有此元素，返回空指针nullptr。

查找代码：

HashData<K, V>* Find(const K& key)
{
	// 根据哈希函数计算位置
	size_t hashi = key % _table.size();
	// 如果状态不为空则继续向后查找
	while (_table[hashi]._status != EMPTY)
	{
		// 找到了并且状态不为删除，则返回此位置的地址
		if (_table[hashi]._status != DELETE &&
			_table[hashi]._kv.first == key)
		{
			return &_table[hashi];
		}
		// 找不到则继续向后找
		else
		{
			++hashi;
			hashi %= _table.size();
		}
			
	}
	// 找到空还未找到返回空指针
	return nullptr;
}

⌛4、删除元素（Erase）⏳


删除元素的思路：

  1. 调用查找函数，看是否有此元素；
  2. 如果找到此元素，直接对此位置的状态置为DELETE；
    • 这就是为什么在查找的时候要判断一下找到的那个节点的位置是否是删除状态；
    • 如果是删除状态并且返回，可能会造成重复删除的可能。
  3. 如果未找到，则返回false。

删除代码：

bool Erase(const K& key)
{
	HashData<K, V>* ret = Find(key);
	if (ret == nullptr)
		return false;
	else
	{
		ret->_status = DELETE;
		return true;
	}
}

4. 字符串哈希


那当我们 插入字符串 的时候应该 用什么样的哈希函数来解决值与位置的对应关系 来实现哈希表呢？

  1. 当我们插入数字的类型，例如：double、float、int、 char、unsigned用的是一种类型的哈希函数；
  2. 当我们插入字符串类型string的时候用的是另一种类型的哈希函数；
  3. 🔎遇到这种情况的时候我们一般用仿函数来解决问题！！！🔍

因此我们要加一个仿函数的模板参数：class HashFunc

对于数字类型的仿函数代码：

template<class K>
struct Hash
{
	size_t operator()(const K& key)
	{
		// 强转即可
		return (size_t)key;
	}
};

对于string类型的仿函数代码：

这里先写一下，待会再细谈：

struct StringFunc
{
	size_t operator()(const string& str)
	{
		size_t ret = 0;
		for (auto& e : str)
		{
			ret *= 131;
			ret += e;
		}
		return ret;
	}
};

由于string类型的哈希我们经常用，因此可以用模板的特化，并将此模板用缺省参数的形式传递，这样我们就不用在每次用的时候传入仿函数了。

template<class K>
struct Hash
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template<>
struct Hash<string>
{
	size_t operator()(const string& str)
	{
		size_t ret = 0;
		for (auto& e : str)
		{
			ret *= 131;
			ret += e;
		}
		return ret;
	}
};

详谈字符串哈希的相关做法


我们用的哈希函数要尽量减少哈希冲突，因此在我们实现字符串转数字的时候也要尽量避免重复数据的出现次数，实际上有很多解决方法，这里有一篇文章，有兴趣的可以看一下：

🎨链接： 字符串哈希算法


其中讲了好几种哈希算法，并进行了很多测试：

在这里插入图片描述

其中效果最好的就是BKDR字符串哈希算法，由于在Brian Kernighan与Dennis Ritchie的《The C Programming Language》一书被展示而得名，是一种简单快捷的hash算法，也是Java目前采用的字符串的Hash算法（累乘因子为31）。

下面代码来自于上述链接：

template<class T>  
size_t BKDRHash(const T *str)  
{  
    register size_t hash = 0;  
    while (size_t ch = (size_t)*str++)  
    {         
        hash = hash * 131 + ch;   // 也可以乘以31、131、1313、13131、131313..  
        // 有人说将乘法分解为位运算及加减法可以提高效率，如将上式表达为：hash = hash << 7 + hash << 1 + hash + ch;  
        // 但其实在Intel平台上，CPU内部对二者的处理效率都是差不多的，  
        // 我分别进行了100亿次的上述两种运算，发现二者时间差距基本为0（如果是Debug版，分解成位运算后的耗时还要高1/3）；  
        // 在ARM这类RISC系统上没有测试过，由于ARM内部使用Booth's Algorithm来模拟32位整数乘法运算，它的效率与乘数有关：  
        // 当乘数8-31位都为1或0时，需要1个时钟周期  
        // 当乘数16-31位都为1或0时，需要2个时钟周期  
        // 当乘数24-31位都为1或0时，需要3个时钟周期  
        // 否则，需要4个时钟周期  
        // 因此，虽然我没有实际测试，但是我依然认为二者效率上差别不大          
    }  
    return hash;  
}

5. 完整代码


🎨博主gitee链接： Jason-of-carriben 闭散列哈希 
#pragma once
#include <iostream>
#include <vector>
using namespace std;

namespace open_adress
{
	enum Status
	{
		EXIST,
		DELETE,
		EMPTY
	};
	template<class K, class V>
	struct HashData
	{
		Status _status = EMPTY;
		pair<K, V> _kv;
	};

	struct StringFunc
	{
		size_t operator()(const string& str)
		{
			size_t ret = 0;
			for (auto& e : str)
			{
				ret *= 131;
				ret += e;
			}
			return ret;
		}
	};

	template<class K>
	struct Hash
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	template<>
	struct Hash<string>
	{
		size_t operator()(const string& str)
		{
			size_t ret = 0;
			for (auto& e : str)
			{
				ret *= 131;
				ret += e;
			}
			return ret;
		}
	};

	template<class K, class V, class Func = Hash<K>>
	class HashTable
	{
	public:
		HashTable(size_t n = 10)
		{
			_table.resize(n);
		}
		bool Insert(const pair<K, V>& kv)
		{
			HashData<K, V>* ret = Find(kv.first);
			if (ret != nullptr)
				return false;
			if (_n * 10 / _table.size() >= 7)
			{
				size_t newsize = 2 * _table.size();
				HashTable<K, V, Func> newHT(newsize);
				for (size_t i = 0; i < _table.size(); ++i)
				{
					if (_table[i]._status == EXIST)
						newHT.Insert(_table[i]._kv);
				}
				_table.swap(newHT._table);
				for (auto& data : _table)
				{
					if (data._status == EXIST)
						++_n;
				}
			}
			Func hf;
			size_t hashi = hf(kv.first) % _table.size();
			while (_table[hashi]._status == EXIST)
			{
				++hashi;
				hashi %= _table.size();
			}
			_table[hashi]._kv = kv;
			_table[hashi]._status = EXIST;
			++_n;
			return true;
		}
		HashData<K, V>* Find(const K& key)
		{
			Func hf;
			size_t hashi = hf(key) % _table.size();
			while (_table[hashi]._status != EMPTY)
			{
				if (_table[hashi]._status != DELETE &&
					_table[hashi]._kv.first == key)
				{
					return &_table[hashi];
				}
				else
				{
					++hashi;
					hashi %= _table.size();
				}
					
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret == nullptr)
				return false;
			else
			{
				ret->_status = DELETE;
				return true;
			}
		}
	private:
		vector<HashData<K, V>> _table;
		size_t _n = 0;
	};

	void HashTest1()
	{
		HashTable<int, int> ht;
		int arr[] = { 10001, 91, 72, 55, 63, 97, 80 };
		for (auto& e : arr)
		{
			ht.Insert(make_pair(e, e));
		}
		ht.Insert(make_pair(93, 93));
	}


	void TestHT3()
	{
		//HashTable<string, int, StringHashFunc> ht;
		HashTable<string, int> ht;
		ht.Insert(make_pair("sort", 1));
		ht.Insert(make_pair("left", 1));
		ht.Insert(make_pair("insert", 1));

		/*cout << StringHashFunc()("bacd") << endl;
		cout << StringHashFunc()("abcd") << endl;
		cout << StringHashFunc()("aadd") << endl;*/
	}


	/*void test_map1()
	{
		string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
	"苹果", "香蕉", "苹果", "香蕉","苹果","草莓", "苹果","草莓" };
		unordered_map<string, int> countMap;
		for (auto& e : arr)
		{
			countMap[e]++;
		}

		cout << countMap.load_factor() << endl;
		cout << countMap.max_load_factor() << endl;
		cout << countMap.size() << endl;
		cout << countMap.bucket_count() << endl;
		cout << countMap.max_bucket_count() << endl;

		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
		cout << endl;
	}*/

}

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

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

相关文章

CAS原理技术

CAS原理技术

CAS原理技术 背景介绍结构体系术语接口原理基础模式1. 首次访问集成CAS Client的应用2. 再次访问集成CAS Client的同一应用3. 访问集成CAS Client的其他应用 代理模式1. 用户在代理服务器上执行身份认证2. 通过代理应用访问其他应用上授权性资源 背景 本文内容大多基于网上其他…
阅读更多...
快速版-JS基础01书写位置

快速版-JS基础01书写位置

1.书写位置 2.标识符 3.变量 var&#xff1a;声明变量。 &#xff08;1&#xff09;.变量的重新赋值 &#xff08;2&#xff09;.变量的提升 打印结果&#xff1a;console.log(变量名) 第一个是你写在里面的。 第二个是实际运行的先后之分&#xff0c;变量名字在最前面。变量…
阅读更多...
牛客NC392 参加会议的最大数目【中等 贪心+小顶堆 Java/Go/PHP 力扣1353】

牛客NC392 参加会议的最大数目【中等 贪心+小顶堆 Java/Go/PHP 力扣1353】

题目 题目链接&#xff1a; https://www.nowcoder.com/practice/4d3151698e33454f98bce1284e553651 https://leetcode.cn/problems/maximum-number-of-events-that-can-be-attended/description/ 思路 贪心优先级队列Java代码 import java.util.*;public class Solution {/**…
阅读更多...
《MySQL怎样运行的》—InnoDB数据页结构

《MySQL怎样运行的》—InnoDB数据页结构

在上一篇文章中我们讲了&#xff0c;InnoDB的数据页是InnoDB管理存储空间的基本单位&#xff0c;一个页的大小基本为16kb 那你有没有疑问&#xff0c;就是说这个InnoDB的数据页的结构是什么样的&#xff0c;还有他这些结构分别有那些功能~接下来我们一一讲解 数据页的总览结构…
阅读更多...
GPT-4o和GPT-4有什么区别？我们还需要付费开通GPT-4？

GPT-4o和GPT-4有什么区别？我们还需要付费开通GPT-4？

GPT-4o 是 OpenAI 最新推出的大模型&#xff0c;有它的独特之处。那么GPT-4o 与 GPT-4 之间的主要区别具体有哪些呢&#xff1f;今天我们就来聊聊这个问题。 目前来看&#xff0c;主要是下面几个差异。 响应速度 GPT-4o 的一个显著优势是其处理速度。它能够更快地回应用户的查…
阅读更多...
java中的Collections类+可变参数

java中的Collections类+可变参数

一、概述 Collections类是集合类的工具类&#xff0c;与数组的工具类Arrays类似 二、可变参数(变&#xff1a;数量) 格式&#xff1a;参数类型名...参数&#xff0c;可变参数就是一个数组 注意&#xff1a;可变参数必须放在参数列表的最后并且一个参数列表只能有一个可变参…
阅读更多...
Golang | Leetcode Golang题解之第101题对称二叉树

Golang | Leetcode Golang题解之第101题对称二叉树

题目&#xff1a; 题解&#xff1a; func isSymmetric(root *TreeNode) bool {u, v : root, rootq : []*TreeNode{}q append(q, u)q append(q, v)for len(q) > 0 {u, v q[0], q[1]q q[2:]if u nil && v nil {continue}if u nil || v nil {return false}if …
阅读更多...
conda 环境找不到 libnsl.so.1

conda 环境找不到 libnsl.so.1

安装prokka后运行报错 perl: error while loading shared libraries: libnsl.so.1: cannot open shared object file: No such file or directory 通过conda list 可以看到 有libsnl 2.00版本&#xff0c;通过修改软链接方式进行欺骗
阅读更多...
Vue3项目练习详细步骤(第一部分：项目构建，登录注册页面)

Vue3项目练习详细步骤(第一部分：项目构建，登录注册页面)

项目环境准备 工程创建 安装依赖 项目调整 注册功能 页面结构 接口文档 数据绑定和校验 数据接口调用 解决跨域问题 登录功能 接口文档 数据绑定和校验 数据接口调用 优化登录/注册成功提示框 项目演示 项目的后端接口参考&#xff1a;https://blog.csdn.net/daf…
阅读更多...
selenium 学习笔记（一）

selenium 学习笔记（一）

pip的安装 新建一个txt curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py 把上面的代码复制进去后&#xff0c;把后缀名改为.bat然后双击运行 当前目录会出现一个这个文件 然后在命令行pyhon get-pip.py等它下好就可以了selenium安装 需要安装到工程目…
阅读更多...
第15章-超声波避障功能 HC-SR04超声波测距模块详解STM32超声波测距

第15章-超声波避障功能 HC-SR04超声波测距模块详解STM32超声波测距

这个是全网最详细的STM32项目教学视频。 第一篇在这里: 视频在这里 STM32智能小车V3-STM32入门教程-openmv与STM32循迹小车-stm32f103c8t6-电赛 嵌入式学习 PID控制算法 编码器电机 跟随 15.1-超声波测距 完成超声波测距功能、测量数据显示在OLED屏幕上 硬件介绍 使用&#…
阅读更多...
react 保持组件纯粹

react 保持组件纯粹

部分 JavaScript 函数是 纯粹 的&#xff0c;这类函数通常被称为纯函数。纯函数仅执行计算操作&#xff0c;不做其他操作。你可以通过将组件按纯函数严格编写&#xff0c;以避免一些随着代码库的增长而出现的、令人困扰的 bug 以及不可预测的行为。但为了获得这些好处&#xff…
阅读更多...
【问题解决】huggingface 离线模型下载

【问题解决】huggingface 离线模型下载

问题 因业务需要在本机测试embedding分词模型&#xff0c;使用 huggingface上的transformers 加载模型时&#xff0c;因为网络无法访问&#xff0c;不能从 huggingface 平台下载模型并加载出现如下错误。 下面提供几种模型下载办法 解决 有三种方式下载模型&#xff0c;一种是通…
阅读更多...
《书生·浦语大模型实战营》第1课 学习笔记：书生·浦语大模型全链路开源体系

《书生·浦语大模型实战营》第1课 学习笔记：书生·浦语大模型全链路开源体系

文章大纲 1. 简介与背景智能聊天机器人与大语言模型目前的开源智能聊天机器人与云上运行模式 2. InternLM2 大模型 简介3. 视频笔记&#xff1a;书生浦语大模型全链路开源体系内容要点从模型到应用典型流程全链路开源体系 4. 论文笔记:InternLM2 Technical Report简介软硬件基础…
阅读更多...
苹果手机数据不慎删除？这4个方法果粉必看！

苹果手机数据不慎删除？这4个方法果粉必看！

苹果手机该怎么恢复丢失的数据呢&#xff1f;有时候会因为使用不当或者是被他人误删等原因&#xff0c;导致重要的数据丢失&#xff0c;这时我们需要找回丢失手机数据&#xff0c;小编给大家分享4种恢复苹果手机数据的技巧&#xff0c;大家赶紧来学一学吧&#xff01; 一、iclo…
阅读更多...
618有哪些值得买的好物？这几款好物通宵整理吐血推荐！

618有哪些值得买的好物？这几款好物通宵整理吐血推荐！

随着618购物节越来越近&#xff0c;很多买家终于等到了用好价钱买好东西的好机会。不管是你一直想要的家居电器&#xff0c;还是最新的数码产品&#xff0c;平时挺贵的东西在618期间会便宜不少。不过&#xff0c;这么多东西可选&#xff0c;促销活动也多得让人看花了眼&#xf…
阅读更多...
SAM遥感图像处理开源新SOTA！在GPU上实现40倍加速，不损准确性

SAM遥感图像处理开源新SOTA！在GPU上实现40倍加速，不损准确性

在遥感图像处理领域&#xff0c;通过SAM捕捉复杂图像特征和细微差异&#xff0c;可以实现高精度的图像分割&#xff0c;提升遥感数据的处理效率。这种高度的准确性让SAM遥感展现出了比传统方法更优越的性能。 不仅如此&#xff0c;这种策略灵活普适的特性还能拓展遥感技术的应…
阅读更多...
Python | Leetcode Python题解之第102题二叉树的层序遍历

Python | Leetcode Python题解之第102题二叉树的层序遍历

题目&#xff1a; 题解&#xff1a; class Solution:def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:if not root: return []res, queue [], collections.deque()queue.append(root)while queue:tmp []for _ in range(len(queue)):node queue.popl…
阅读更多...
Unity3D让BoxCollider根据子物体生成自适应大小

Unity3D让BoxCollider根据子物体生成自适应大小

系列文章目录 unity工具 文章目录 系列文章目录unity工具 &#x1f449;前言&#x1f449;一、编辑器添加&#x1f449;二、代码动态添加的方法(第一种)&#x1f449;三、代码动态添加的方法(第二种)&#x1f449;四、重新设置模型的中心点&#x1f449;壁纸分享&#x1f449;…
阅读更多...
分布式事务解决方案（最终一致性【可靠消息解决方案】）

分布式事务解决方案（最终一致性【可靠消息解决方案】）

可靠消息最终一致性解决方案 可靠消息最终一致性分布式事务解决方案指的是事务的发起方执行完本地事务之后&#xff0c;发出一条消息&#xff0c;事务的参与方&#xff0c;也就是消息的消费者一定能够接收到这条消息并且处理完成&#xff0c;这个方案强调的是只要事务发起方将消…
阅读更多...
最新文章

Copyright @ 2022~2023