C++哈希表的实现

C++哈希表的实现

  • 一.unordered系列容器的介绍
  • 二.哈希介绍
    • 1.哈希概念
    • 2.哈希函数的常见设计
    • 3.哈希冲突
    • 4.哈希函数的设计原则
  • 三.解决哈希冲突
    • 1.闭散列(开放定址法)
      • 1.线性探测
        • 1.动图演示
        • 2.注意事项
        • 3.代码的注意事项
        • 4.代码实现
    • 2.开散列(哈希桶,拉链法)
      • 1.概念
      • 2.动图演示
      • 3.增容问题
        • 1.拉链法的负载因子
          • 2.说明
    • 3.开散列和闭散列的比较
  • 四.开散列哈希表的实现
    • 1.跟闭散列哈希表相同的部分
    • 2.析构,查找,删除
      • 1.析构
      • 2.查找
      • 3.删除
    • 3.插入
      • 1.不扩容的代码
      • 2.扩容代码
      • 3.插入的完整代码
    • 4.开散列哈希表的完整代码

一.unordered系列容器的介绍

在这里插入图片描述
在这里插入图片描述

二.哈希介绍

1.哈希概念

在这里插入图片描述

2.哈希函数的常见设计

在这里插入图片描述

3.哈希冲突

在这里插入图片描述

4.哈希函数的设计原则

在这里插入图片描述

三.解决哈希冲突

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

1.闭散列(开放定址法)

在这里插入图片描述
因为线性探测跟二次探测很像,所以这里就只实现线性探测了

1.线性探测

1.动图演示

在这里插入图片描述
在这里插入图片描述

2.注意事项

在这里插入图片描述

3.代码的注意事项

1.仿函数的问题:
(1).因为string类型不能进行取模运算,因此给string类型增加一个仿函数
该仿函数可以将string转为整型,整型可以进行取模运算
因此这就相当于二层映射
string -> int -> 哈希表中的下标
(2)
因为这里要考虑到顺序问题,比如"abc",“acb”
或者ASCII码值相等的问题:“aad”,“abc”
所以很多大佬设计了很多字符串哈希算法
各种字符串Hash函数
大家感兴趣的话可以看这篇博客当中的介绍

(3)因为string类型的哈希映射太常用了,
所以这里使用了模板特化,以免每次要存放string时都要指名传入string的哈希函数

这里的哈希函数只返回了整形值,计算下标时一定不要忘了对哈希表大小取模
否则就会有vector的越界错误,直接assert断言暴力报错了

哈希表是Key-Value模型
哈希下标是按照Key来计算的

//仿函数
//整型的hash函数
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)
	{
		// BKDR字符串哈希函数
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 131;
			hash += e;
		}
		return hash;
	}
};

template<class K, class V, class Hash = HashFunc<K>>
class HashTable
....
4.代码实现
namespace open_address
{
	enum Status
	{
		EMPTY,
		EXIST,
		DELETE
	};

	template<class K, class V>
	struct HashData
	{
		pair<K, V> _kv;
		Status _s;         //状态
	};

	//仿函数
	//整型的hash函数
	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)
		{
			// BKDR字符串哈希函数
			size_t hash = 0;
			for (auto e : key)
			{
				hash *= 131;
				hash += e;
			}
			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, Hash> 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 NULL;
		}

		// 伪删除法
		bool Erase(const K& key)
		{
			HashData<K, V>* ret = Find(key);
			if (ret)
			{
				ret->_s = DELETE;
				--_n;
				return true;
			}
			else
			{
				return false;
			}
		}

	private:
		vector<HashData<K, V>> _tables;
		size_t _n = 0; // 存储的关键字的个数
	};
}

2.开散列(哈希桶,拉链法)

上面的闭散列并不好用,因此我们重点介绍和实现开散列方法

1.概念

在这里插入图片描述

2.动图演示

插入之前:
在这里插入图片描述
插入过程:
在这里插入图片描述
插入之后:
在这里插入图片描述

3.增容问题

1.拉链法的负载因子

在这里插入图片描述
注意:扩容时因为要将下标重新映射所以扩容会使一个桶当中的数据被打散到不同的桶当中,使得这种极端情况很难发生

2.说明

1.对于这里的哈希桶我们采用单链表
2.为了后续使用开散列的哈希桶封装unordered_set和unordered_map,我们不使用STL库中的forward_list(C++11新增容器:单链表),而是自己手撕单链表
3.因为这里的单链表是我们自己实现的,所以要写析构函数,不能使用编译器默认生成的析构函数
4.为了提高效率,哈希表增容时我们直接转移节点,并不会去进行节点的深拷贝,那样太浪费空间了
5.开散列的哈希表无非就是一个指针数组而已,所以大家不要有任何的害怕
AVL树和红黑树我们都能实现,哈希表怕什么…

3.开散列和闭散列的比较

在这里插入图片描述

四.开散列哈希表的实现

1.跟闭散列哈希表相同的部分

namespace wzs
{
	//HashFunc<int>
	template<class K>
	//整型的哈希函数
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};
	//HashFunc<string>
	//string的哈希函数
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& key)
		{
			// BKDR
			size_t hash = 0;
			for (auto e : key)
			{
				hash *= 131;
				hash += e;
			}
			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();

		bool Insert(const pair<K, V>& kv);

		Node* Find(const K& key);

		bool Erase(const K& key);
		
	private:
		//哈希表是一个指针数组
		vector<Node*> _tables;
		size_t _n = 0;
		Hash hash;
	};
}

2.析构,查找,删除

1.析构

析构就是遍历哈希表,把每个单链表都销毁即可

~HashTable()
{
	for (int i = 0; i < _tables.size(); i++)
	{
		Node* cur = _tables[i];
		while (cur)
		{
			Node* next = cur->_next;
			delete cur;
			cur = next;
		}
		_tables[i] = nullptr;
	}
}

2.查找

1.根据哈希函数计算出下标,找到对应的哈希桶
2.遍历哈希桶,找数据即可
3.找到则返回该节点,找不到返回空指针

Node* Find(const K& key)
{
	int hashi = hash(key) % _tables.size();
	Node* cur = _tables[hashi];
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			return cur;
		}
		cur = cur->_next;
	}
	return nullptr;
}

3.删除

删除就是找到该节点,让该节点的前驱指向该节点的后继,然后delete该节点
注意:
如果该节点是该哈希桶的头节点,直接让该哈希桶的头节点成为该节点的后继,然后delete该节点即可

bool Erase(const K& key)
{
	int hashi = hash(key) % _tables.size();
	Node* cur = _tables[hashi], * prev = nullptr;
	while (cur)
	{
		if (cur->_kv.first == key)
		{
			if (cur == _tables[hashi])
			{
				_tables[hashi] = cur->_next;
			}
			else
			{
				prev->_next = cur->_next;
			}
			return true;
		}
		prev = cur;
		cur = cur->_next;
	}
	return false;
}

3.插入

因为我们的哈希表不支持存放重复值,所以插入时
1.先查找在不在,如果在,返回false表示插入失败
2.不在,判断是否需要扩容,如果需要,则进行扩容
3.插入时,先根据哈希函数计算出对应的下标,然后找到该哈希桶头插即可

1.不扩容的代码

bool Insert(const pair<K, V>& kv)
{
	//先查找在不在
	//如果在,返回false,插入失败
	if (Find(kv.first))
	{
		return false;
	}
	//扩容....
	//1.利用哈希函数计算需要插入到那个桶里面
	int hashi = hash(kv.first) % _tables.size();
	//头插
	Node* newnode = new Node(kv);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}

2.扩容代码

1.开辟新的哈希表
2.将新哈希表的容量扩为2倍(一定要做,因为转移数据时需要根据新表的大小映射下标)
3.转移数据时
(1).遍历旧表取节点
(2).利用哈希函数计算该节点在新表中的下标
(3).头插该节点
4.转移完数据后不要忘记把旧表中的哈希桶的节点置空,否则会出现野指针问题

bool Insert(const pair<K, V>& kv)
{
	//扩容
	if (_n == _tables.size())
	{
		//开辟新的哈希表
		HashTable newtable;
		int newcapacity = _tables.size() * 2;
		//扩2倍
		newtable._tables.resize(newcapacity);
		//转移数据
		for (int i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				int hashi = hash(cur->_kv.first) % newtable._tables.size();
				cur->_next = newtable._tables[hashi];
				newtable._tables[hashi] = cur;
				cur = next;
			}
			//防止出现野指针导致重复析构...
			_tables[i] = nullptr;
		}
	}
}

3.插入的完整代码

bool Insert(const pair<K, V>& kv)
{
	//先查找在不在
	//如果在,返回false,插入失败
	if (Find(kv.first))
	{
		return false;
	}
	//扩容
	if (_n == _tables.size())
	{
		//开辟新的哈希表
		HashTable newtable;
		int newcapacity = _tables.size() * 2;
		//扩2倍
		newtable._tables.resize(newcapacity);
		//转移数据
		for (int i = 0; i < _tables.size(); i++)
		{
			Node* cur = _tables[i];
			while (cur)
			{
				Node* next = cur->_next;
				int hashi = hash(cur->_kv.first) % newtable._tables.size();
				cur->_next = newtable._tables[hashi];
				newtable._tables[hashi] = cur;
				cur = next;
			}
			//防止出现野指针导致重复析构...
			_tables[i] = nullptr;
		}
		//交换两个vector,从而做到交换两个哈希表
		//通过学习vector的模拟实现,我们知道vector进行交换时只交换first,finish,end_of_storage
		_tables.swap(newtable._tables);
	}
	//1.利用哈希函数计算需要插入到那个桶里面
	int hashi = hash(kv.first) % _tables.size();
	//头插
	Node* newnode = new Node(kv);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_n;
	return true;
}

4.开散列哈希表的完整代码

namespace wzs
{
	//HashFunc<int>
	template<class K>
	//整型的哈希函数
	struct HashFunc
	{
		size_t operator()(const K& key)
		{
			return (size_t)key;
		}
	};

	//HashFunc<string>
	//string的哈希函数
	template<>
	struct HashFunc<string>
	{
		size_t operator()(const string& key)
		{
			// BKDR
			size_t hash = 0;
			for (auto e : key)
			{
				hash *= 131;
				hash += e;
			}
			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 (int 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)
		{
			//先查找在不在
			//如果在,返回false,插入失败
			if (Find(kv.first))
			{
				return false;
			}
			//扩容
			if (_n == _tables.size())
			{
				//开辟新的哈希表
				HashTable newtable;
				int newcapacity = _tables.size() * 2;
				//扩2倍
				newtable._tables.resize(newcapacity);
				//转移数据
				for (int i = 0; i < _tables.size(); i++)
				{
					Node* cur = _tables[i];
					while (cur)
					{
						Node* next = cur->_next;
						int hashi = hash(cur->_kv.first) % newtable._tables.size();
						cur->_next = newtable._tables[hashi];
						newtable._tables[hashi] = cur;
						cur = next;
					}
					//防止出现野指针导致重复析构...
					_tables[i] = nullptr;
				}
				//交换两个vector,从而做到交换两个哈希表
				//通过学习vector的模拟实现,我们知道vector进行交换时只交换first,finish,end_of_storage
				_tables.swap(newtable._tables);
			}
			//1.利用哈希函数计算需要插入到那个桶里面
			int hashi = hash(kv.first) % _tables.size();
			//头插
			Node* newnode = new Node(kv);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_n;
			return true;
		}

		Node* Find(const K& key)
		{
			int 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)
		{
			int hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi], * prev = nullptr;
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (cur == _tables[hashi])
					{
						_tables[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					return true;
				}
				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

	private:
		//哈希表是一个指针数组
		vector<Node*> _tables;
		size_t _n = 0;
		Hash hash;
	};
}

以上就是C++哈希表的实现的全部内容,希望能对大家有所帮助!

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

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

相关文章

互联网+建筑工地源码，基于微服务+Java+Spring Cloud +Vue+UniApp开发

互联网+建筑工地源码，基于微服务+Java+Spring Cloud +Vue+UniApp开发

一、智慧工地概念 智慧工地就是互联网建筑工地&#xff0c;是将互联网的理念和技术引入建筑工地&#xff0c;然后以物联网、移动互联网技术为基础&#xff0c;充分应用BIM、大数据、人工智能、移动通讯、云计算、物联网等信息技术&#xff0c;通过人机交互、感知、决策、执行和…
阅读更多...
【YOLOV8预测篇】使用Ultralytics YOLO进行检测、分割、姿态估计和分类实践

【YOLOV8预测篇】使用Ultralytics YOLO进行检测、分割、姿态估计和分类实践

目录 一 安装Ultralytics 二 使用预训练的YOLOv8n检测模型 三 使用预训练的YOLOv8n-seg分割模型 四 使用预训练的YOLOv8n-pose姿态模型 五 使用预训练的YOLOv8n-cls分类模型 <
阅读更多...
序列化和反序列化对比分析，序列化和反序列化输出十个学生信息截图

序列化和反序列化对比分析，序列化和反序列化输出十个学生信息截图

序列化和反序列化是数据处理中的两个相对的概念&#xff0c;通常用于对象的存储和传输。下面是对这两个过程的对比分析&#xff1a; 序列化&#xff08;Serialization&#xff09; 定义 目的&#xff1a; 将对象的状态信息转换成可以存储或传输的形式&#xff08;如XML, JSO…
阅读更多...
算数平均数、调和平均数、几何平均数的计算方法与应用场合

算数平均数、调和平均数、几何平均数的计算方法与应用场合

一 定义 1、算数平均数&#xff1a;又称均值&#xff0c;是统计学中最基本&#xff0c;最常用的一种平均指标&#xff0c;分为简单算术平均数、加权算术平均数。 2、调和平均数&#xff1a;又称倒数平均数&#xff0c;是总体各统计变量倒数的算数平均数的倒数。分为数学调和平…
阅读更多...
Yolov5水果分类识别+pyqt交互式界面

Yolov5水果分类识别+pyqt交互式界面

Yolov5 Fruits Detector Yolov5 是一种先进的目标检测算法&#xff0c;可以应用于水果分类识别任务。结合 PyQT 框架&#xff0c;可以创建一个交互式界面&#xff0c;使用户能够方便地上传图片并获取水果分类结果。以下将详细阐述 Yolov5 水果分类识别和 PyQT 交互式界面的实现…
阅读更多...
什么是网络工程师? 就业前景好吗？

什么是网络工程师? 就业前景好吗？

互联网发展日渐成熟&#xff0c;所有企业都依赖于网络管理&#xff0c;有企业的地方就需要网络工程师。 在一般人的概念里&#xff0c;网络工程师不过就是通过拨号上网&#xff0c;发个Email&#xff0c;聊聊天&#xff0c;计算机组装与维护&#xff0c;组建局域网就以为是网络…
阅读更多...
Node.js安装部署

Node.js安装部署

Node.js安装部署 在 Windows 上安装 Node.js1.使用安装程序2.使用包管理器 Chocolatey 安装 在 macOS 上安装 Node.js1.使用 Homebrew 安装 在 Linux 上安装 Node.js1.使用包管理器安装2.使用 Node.js 官方二进制包 安装完成验证 Node.js 是一个基于 Chrome V8 引擎的 JavaScri…
阅读更多...
threejs中修改鼠标cursor不生效的问题修复

threejs中修改鼠标cursor不生效的问题修复

需求&#xff1a; 当鼠标hover一个元素时&#xff0c;cursor为自定义的图标 问题描述&#xff1a; threejs中修改canvas的鼠标cursor为自定义的图标不生效。 问题原因&#xff1a; 引入了dragcontrols&#xff0c;查看dragControls的代码&#xff0c;可以看到代码中有对cur…
阅读更多...
XPM_CDC_PULSE

XPM_CDC_PULSE

MACRO_GROUP: XPM MACRO_SUBGROUP: XPM_CDC 1、Introduction 此宏将源时钟域中的脉冲同步到目标时钟域。源时钟域中任何大小的脉冲&#xff0c;如果正确启动&#xff0c;将生成单个目标时钟周期大小的脉冲。 为了正确操作&#xff0c;输入数据必须由目标时钟采样两次或…
阅读更多...
饥荒Mod 开发(二一)：超大便携背包，超大物品栏，永久保鲜

饥荒Mod 开发(二一)：超大便携背包，超大物品栏，永久保鲜

饥荒Mod 开发(二十)&#xff1a;显示打怪伤害值 源码 游戏中的物品栏容量实在太小了&#xff0c;虽然可以放在箱子里面但是真的很不方便&#xff0c;外出一趟不容易看到东西都不能捡。实在是虐心。 游戏中的食物还有变质机制&#xff0c;时间长了就不能吃了&#xff0c;玩这个游…
阅读更多...
如何在Portainer部署一个web站点到Nginx容器并结合内网穿透远程访问

如何在Portainer部署一个web站点到Nginx容器并结合内网穿透远程访问

文章目录 前言1. 安装Portainer1.1 访问Portainer Web界面 2. 使用Portainer创建Nginx容器3. 将Web静态站点实现公网访问4. 配置Web站点公网访问地址4.1公网访问Web站点 5. 固定Web静态站点公网地址6. 固定公网地址访问Web静态站点 前言 Portainer是一个开源的Docker轻量级可视…
阅读更多...
大语言模型的三种主要架构 Decoder-Only、Encoder-Only、Encoder-Decoder

大语言模型的三种主要架构 Decoder-Only、Encoder-Only、Encoder-Decoder

现代大型语言模型&#xff08;LLM&#xff09;的演变进化树&#xff0c;如下图&#xff1a; https://arxiv.org/pdf/2304.13712.pdf 基于 Transformer 模型以非灰色显示&#xff1a; decoder-only 模型在蓝色分支&#xff0c; encoder-only 模型在粉色分支&#xff0c; encod…
阅读更多...
国际站店铺装修外贸平台alibaba鼠标经过渐变的效果功能代码代码生成器店铺装修旺铺旺铺装修生成器阿里巴巴国际站店铺怎么装修首页进入装修后台自定义内容模块

国际站店铺装修外贸平台alibaba鼠标经过渐变的效果功能代码代码生成器店铺装修旺铺旺铺装修生成器阿里巴巴国际站店铺怎么装修首页进入装修后台自定义内容模块

国际站店铺装修外贸平台alibaba鼠标经过渐变的效果功能代码代码生成器店铺装修旺铺旺铺装修生成器阿里巴巴国际站店铺怎么装修首页进入装修后台自定义内容模块 鼠标经过有个渐变的效果功能
阅读更多...
寒风中，新能源汽车续航严重打折，消费者重投燃油车怀抱

寒风中，新能源汽车续航严重打折，消费者重投燃油车怀抱

统计数据显示&#xff0c;12月12日至12月17日这一周&#xff0c;燃油车销量大幅反弹&#xff0c;燃油车的环比增速远高于新能源汽车领军者比亚迪&#xff0c;似乎显示出消费者再度青睐燃油车&#xff0c;导致如此结果在于新能源汽车在寒冬中的表现让人失望。 一、燃油车销量增速…
阅读更多...
python读取Excel内容并展示成json

python读取Excel内容并展示成json

shigen坚持更新文章的博客写手&#xff0c;擅长Java、python、vue、shell等编程语言和各种应用程序、脚本的开发。记录成长&#xff0c;分享认知&#xff0c;留住感动。 伙伴们&#xff0c;又是许久未曾见面了。最近也是在忙着加班&#xff0c;加上没有新技术的输入和产出&…
阅读更多...
Linux Centos-7.5_64bit 系统等保测评内容

Linux Centos-7.5_64bit 系统等保测评内容

一、身份鉴别 a) 应对登录的用户进行身份标识和鉴别&#xff0c;身份标识具有唯一性&#xff0c;身份鉴别信息具有复杂度要求并定期更换 指引&#xff1a;1.观察管理员登录方式。2.查看系统配置&#xff0c;记录配置参数。&#xff08;more /etc/pam.d/system-auth、more /et…
阅读更多...
C语言：差分

C语言：差分

【模板】差分_牛客题霸_牛客网 (nowcoder.com) 上图中[1,2]4d[0]4,d[1]4,d[2]4,d[3]4...d[2]-4,d[3]-4... [3,3]-2d[2]-2,d[3]-2,d[4]-2....d[3]2,d[4]2... 通过求前缀和操作&#xff0c;相当于用另一个数组完成了差分操作&#xff0c;再将原数组加上该数组&#xff0c;即可得…
阅读更多...
HTML+CSS做一个时尚柿子造型计时器

HTML+CSS做一个时尚柿子造型计时器

文章目录 💕效果展示💕代码展示HTMLJS💕效果展示 💕代码展示 HTML <!DOCTYPE html> <html lang
阅读更多...
ABS210-ASEMI手机适配器整流桥ABS210

ABS210-ASEMI手机适配器整流桥ABS210

编辑&#xff1a;ll ABS210-ASEMI手机适配器整流桥ABS210 型号&#xff1a;ABS210 品牌&#xff1a;ASEMI 封装&#xff1a;ABS-4 特性&#xff1a;贴片、整流桥 最大平均正向电流&#xff1a;2A 最大重复峰值反向电压&#xff1a;1000V 恢复时间&#xff1a;&#xff…
阅读更多...
java SSM家庭财务管理系统myeclipse开发mysql数据库springMVC模式java编程计算机网页设计

java SSM家庭财务管理系统myeclipse开发mysql数据库springMVC模式java编程计算机网页设计

一、源码特点 java SSM家庭财务管理系统是一套完善的web设计系统&#xff08;系统采用SSM框架进行设计开发&#xff0c;springspringMVCmybatis&#xff09;&#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代 码和数据库&#xff0c;系统主要采…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站