C++进阶——哈希的实现

news2024/11/24 22:51:32

C++进阶——哈希的实现

unordered系列关联式容器

在C++11出现中有了重大更新就是添加了移动构造和unordered关联容器。

在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到O( l o g 2 N log_2 N log2​N)，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。最好的查询是，进行很少的比较次数就能够将元素找到，因此在C++11中，STL又提供了4个unordered系列的关联式容器，这四个容器与红黑树结构的关联式容器使用方式基本类似，只是其底层结构不同，本文中只对unordered_map和unordered_set进行介绍，unordered_multimap和unordered_multiset学生可查看文档介绍。

unordered_map

  1. unordered_map是存储<key, value>键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。
  2. 在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。键和映射值的类型可能不同。
  3. 在内部,unordered_map没有对<kye, value>按照任何特定的顺序排序, 为了能在常数范围内找到key所对应的value，unordered_map将相同哈希值的键值对放在相同的桶中。
  4. unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。
  5. unordered_maps实现了直接访问操作符(operator[])，它允许使用key作为参数直接访问value。
  6. 它的迭代器至少是前向迭代器（单向只增）。

unordered_set

其实和set基本功能是一样的，但是没有排序能力。

底层结构

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

哈希概念

顺序结构以及平衡树中，元素关键码与其存储位置之间没有对应的关系，因此在查找一个元素
时，必须要经过关键码的多次比较。顺序查找时间复杂度为O(N)，平衡树中为树的高度，即
O( l o g 2 N log_2 N log2​N)，搜索的效率取决于搜索过程中元素的比较次数。
理想的搜索方法：可以不经过任何比较，一次直接从表中得到要搜索的元素。如果构造一种存储结构，通过某种函数(hashFunc)使元素的存储位置与它的关键码之间能够建立一一映射的关系，那么在查找时通过该函数可以很快找到该元素。
当向该结构中：

  • 插入元素
    根据待插入元素的关键码，以此函数计算出该元素的存储位置并按此位置进行存放
  • 搜索元素
    对元素的关键码进行同样的计算，把求得的函数值当做元素的存储位置，在结构中按此位置
    取元素比较，若关键码相等，则搜索成功
    该方式即为哈希(散列)方法，哈希方法中使用的转换函数称为哈希(散列)函数，构造出来的结构称
    为哈希表(Hash Table)(或者称散列表)
    例如：数据集合{1，7，6，4，5，9}；
    哈希函数设置为：hash(key) = key % capacity; capacity为存储元素底层空间总的大小。
    在这里插入图片描述
    用该方法进行搜索不必进行多次关键码的比较，因此搜索的速度比较快
    问题：按照上述哈希方式，向集合中插入元素44，会出现什么问题？
    答：会出现44和4同时都指向下标4这个位置，4不就会被取代了，这该怎么办呢？

哈希冲突

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

  • 把具有不同关键码而具有相同哈希地址的数据元素称为“同义词”。

发生哈希冲突该如何处理呢？

哈希函数

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

  • 哈希函数的定义域必须包括需要存储的全部关键码，而如果散列表允许有m个地址时，其值域必须在0到m-1之间
  • 哈希函数计算出来的地址能均匀分布在整个空间中
  • 哈希函数应该比较简单

常见哈希函数

  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种不同的符号在各位上出现的频率不一定
    相同，可能在某些位上分布比较均匀，每种符号出现的机会均等，在某些位上分布不均匀只
    有某几种符号经常出现。可根据散列表的大小，选择其中各种符号分布均匀的若干位作为散
    列地址。
    注意：哈希函数设计的越精妙，产生哈希冲突的可能性就越低，但是无法避免哈希冲突

哈希冲突解决

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

  1. 线性探测
    比如2.1中的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，hashAddr为4，
    因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。
    线性探测：从发生冲突的位置开始，依次向后探测，直到寻找到下一个空位置为止。
    插入
    通过哈希函数获取待插入元素在哈希表中的位置
    如果该位置中没有元素则直接插入新元素，如果该位置中有元素发生哈希冲突，
    使用线性探测找到下一个空位置，插入新元素
    在这里插入图片描述
    删除
    采用闭散列处理哈希冲突时，不能随便物理删除哈希表中已有的元素，若直接删除元素
    会影响其他元素的搜索。比如删除元素4，如果直接删除掉，44查找起来可能会受影
    响。因此线性探测采用标记的伪删除法来删除一个元素。

     // 哈希表每个空间给个标记
 // EMPTY此位置空， EXIST此位置已经有元素， DELETE元素已经删除
 enum State{EMPTY, EXIST, DELETE};

线性探测的实现

#pragma once
#ifndef __HASH_H__
#define __HASH_H__
#include<iostream>
#include<vector>
using namespace std;
namespace tom
{
	enum State
	{
		EMPTY,
		EXIST,
		DELETE
	};
	template<class K,class V>
	struct HashData
	{
		pair<K, V> _kv;
		State _state = EMPTY;
	};

	template<class K, class V>
	class HashTable
	{
	public:
		HashData<K,V>* Find(const K& key)//返回的是数据指针
		{
			if (_table.size() == 0)
			{
				//return false;//为什么返回false？
				return nullptr;
			}

			size_t hashi = key % _table.size();
			//线性探测
			size_t i = 1;
			size_t index = hashi;
			while (_table[index]._state != EMPTY)
			{
				if (_table[index]._state == EXIST&&_table[index]._kv.first==key)
				{
					return &_table[index];
				}
				index = hashi + i;
				index %= _table.size();
				++i;
				if (index == hashi)
				{
					break;
				}
			}
			return nullptr;
		}

		bool Erase(const K& key)
		{

			HashData<K, V>* res = Find(key);
			if (res)
			{
				res->_state = DELETE;
				--_count;
				return true;
			}
			return false;
		}

		bool Insert(const pair<K, V>& kv)
		{
			if(Find(kv.first)) return false;
			if (_table.size() == 0 || _count * 10 / _table.size() >= 7)//扩容，还能再办？
			{
				size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
				HashTable<K, V> newHt;
				newHt._table.resize(newsize);
				for (auto& data : _table)
				{
					if (data._state == EXIST)
					{
						newHt.Insert(data._kv);//自己掉自己——容量超标的调用一个容量不超标的。不会产生死循环！
					}
				}
				_table.swap(newHt._table);
			}
			size_t hashi = kv.first % _table.size();
			size_t i = 1;
			size_t index = hashi;
			while (_table[index]._state == EXIST)
			{
				index = hashi + i;
				index %= _table.size();
				++i;
			}

			_table[index]._kv = kv;
			_table[index]._state = EXIST;
			_count++;

			return true;
		}
	private:
		vector<HashData<K, V>> _table;
		size_t _count = 0;//存了多少数据，利用vector的性质减少了封装。
	};
}

#endif // !__HASH_H__

扩容
在实现哈希函数的时候还要考虑扩容，什么时候扩容呢？是满了以后才扩容吗？
这里要引入一个定义：载荷因子（负载因子），当载荷因子=0.7时就开始扩容。
载荷因子怎么算呢：已经存在的数的个数count/哈希表的size= a a a (载荷因子)。

不需要单独写一个扩容函数了，你如果想要封装也是可以的，我单独拿出来了。
但是要记住我们的count和size都是size_t类型整数，所以不能和0.7这样的浮点数比较，于是要两边都乘十，这样就解决了。

if (_table.size() == 0 || _count * 10 / _table.size() >= 7)//扩容
			{
				size_t newsize = _table.size() == 0 ? 10 : _table.size() * 2;
				HashTable<K, V> newHt;
				newHt._table.resize(newsize);
				for (auto& data : _table)
				{
					if (data._state == EXIST)
					{
						newHt.Insert(data._kv);//自己掉自己——容量超标的调用一个容量不超标的。不会产生死循环！
					}
				}
				_table.swap(newHt._table);
			}
			size_t hashi = kv.first % _table.size();
			size_t i = 1;
			size_t index = hashi;
			while (_table[index]._state == EXIST)
			{
				index = hashi + i;
				index %= _table.size();
				++i;
			}

测试函数

void TestHashTable1()
{
	int a[] = { 3, 33, 2, 13, 5, 12, 1002 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.Insert(make_pair(e, e));
	}

	ht.Insert(make_pair(15, 15));

	if (ht.Find(1002))
	{
		cout << "1002在" << endl;
	}
	else
	{
		cout << "1002不在" << endl;
	}

	ht.Erase(13);

	if (ht.Find(13))
	{
		cout << "13在" << endl;
	}
	else
	{
		cout << "13不在" << endl;
	}
}

在这里插入图片描述

测试成功！

开散列

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

在这里插入图片描述
从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

开散列实现

#pragma once
#ifndef __HASHBUCKET_H__
#define __HASHBUCKET_H__
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
namespace tom
{
	template<class K, class V>
	struct HashNode
	{
		HashNode<K, V>* _next;
		pair<K, V> _kv;
		
		HashNode(const pair<K, V>& kv)
			:_next(nullptr)
			,_kv(kv)
		{

		}
	};

	template<class K, class V>
	class HashTable
	{
		typedef HashNode<K, V> node;
	public:
		~HashTable()
		{
			for (auto& cur : _table)
			{
				while (cur)
				{
					node* next = cur->_next;
					delete cur;
					cur = next;
				}
				cur = nullptr;
			}	
		}

		node* find(const K&key)
		{
			if (_table.size() == 0)
				return nullptr;
			size_t hashi = key % _table.size();
			node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					return cur;
				}
				cur = cur->_next;
			}
			return nullptr;
		}
		bool erase(const K&key)
		{
			if (!find(key)) return false;

			size_t hashi = key % _table.size();
			node* prev = nullptr;
			node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_table[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					break;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			--_count;
			return true;
		}
		bool insert(const pair<K,V>& kv)
		{
			if (find(kv.first)) return false;
			if (_count == _table.size())//载荷因子为 1 .就开始扩容。
			{
				size_t newsize = _table.size () ? _table.size() * 2 : 10;//让我试一下这样行不行 
				//size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<node*> newtable(newsize, nullptr);
				for (auto& cur : _table)
				{
					while (cur)
					{
						node* next = cur->_next;//记录旧表的next，不然经过下面的转换就会找不到旧表的next了
						size_t hashi = cur->_kv.first % newsize;
						cur->_next = newtable[hashi];
						newtable[hashi] = cur;
						cur = next;
					}
				}
				_table.swap(newtable);
			}

			size_t hashi = kv.first % _table.size();
			node* newnode = new node(kv);
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			++_count;
			return true;
		}
	private:
		vector<node*> _table; //指针数组
		int _count = 0;//有效数据的个数
	};
}

#endif // !__HASHBUCKET_H__

插入：
我们采用头插进行插入数据，这样更加方便操作，维察也可以不过数据链一多，还要挨个遍历一遍哈希桶太臃肿了。
在这里插入图片描述
最后变成如下图：
在这里插入图片描述

bool insert(const pair<K,V>& kv)
		{
			if (find(kv.first)) return false;
			if (_count == _table.size())//载荷因子为 1 .就开始扩容。
			{
				size_t newsize = _table.size () ? _table.size() * 2 : 10;//让我试一下这样行不行 
				//size_t newsize = _tables.size() == 0 ? 10 : _tables.size() * 2;
				vector<node*> newtable(newsize, nullptr);
				for (auto& cur : _table)
				{
					while (cur)
					{
						node* next = cur->_next;//记录旧表的next，不然经过下面的转换就会找不到旧表的next了
						size_t hashi = cur->_kv.first % newsize;
						cur->_next = newtable[hashi];
						newtable[hashi] = cur;
						cur = next;
					}
				}
				_table.swap(newtable);
			}

			size_t hashi = kv.first % _table.size();
			node* newnode = new node(kv);
			newnode->_next = _table[hashi];
			_table[hashi] = newnode;
			++_count;
			return true;
		}

这里也要考虑负载因子a不过可以控制在1就可以了。if (_count == _table.size())//载荷因子为 1 .就开始扩容。

扩容是怎么样的呢？扩容+改变数据的位置。
如下图：
在这里插入图片描述

删除：
删除就是一个一个查找然后删掉，不过有一个问题要注意：就删除的要是链头就直接用next替代链头（头删），中间或者尾部就是普通删除。

bool erase(const K&key)
		{
			if (!find(key)) return false;

			size_t hashi = key % _table.size();
			node* prev = nullptr;
			node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_table[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					break;
				}
				else
				{
					prev = cur;
					cur = cur->_next;
				}
			}
			--_count;
			return true;
		}

测试函数

void TestHashTable1()
{
	int a[] = { 3, 33, 2, 13, 5, 12, 1002 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.insert(make_pair(e, e));
	}

	ht.insert(make_pair(15, 15));
	ht.insert(make_pair(25, 25));
	ht.insert(make_pair(35, 35));
	ht.insert(make_pair(45, 45));

}

void TestHashTable2()
{
	int a[] = { 3, 33, 2, 13, 5, 12, 1002 };
	HashTable<int, int> ht;
	for (auto e : a)
	{
		ht.insert(make_pair(e, e));
	}

	ht.erase(12);
	ht.erase(3);
	ht.erase(33);
}

在这里插入图片描述
测试成功！

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

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

相关文章

MYSQL高级之关联查询优化

MYSQL高级之关联查询优化

建表 CREATE TABLE IF NOT EXISTS class ( id INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, card INT(10) UNSIGNED NOT NULL, PRIMARY KEY (id) ); CREATE TABLE IF NOT EXISTS book ( bookid INT(10) UNSIGNED NOT NULL AUTO_INCREMENT, card INT(10) UNSIGNED NOT NULL, PRI…
阅读更多...
vue router实现路由跳转方法

vue router实现路由跳转方法

今天在学习 vue的过程中&#xff0c;看到了 vue的 router&#xff0c;用它来实现路由跳转&#xff0c;非常方便&#xff0c;于是就尝试了一下。效果还不错。 首先我们需要了解一个概念&#xff1a; Router。 Router是一个接口&#xff0c;它提供了一个接口让我们可以从一个地方…
阅读更多...
Flutter 笔记 | Flutter 核心原理（二）关键类和启动流程

Flutter 笔记 | Flutter 核心原理（二）关键类和启动流程

Widget、Element、BuildContext 和 RenderObject Widget Widget关键类及其子类继承关系如图所示&#xff1a; 其中&#xff0c;Widget是Widget Tree所有节点的基类。Widget的子类主要分为3类&#xff1a; 第1类是RenderObjectWidget的子类&#xff0c;具体来说又分为SingleCh…
阅读更多...
08. 算法之递归算法

08. 算法之递归算法

前言 递归&#xff0c;字面意思是递出去&#xff0c;拿回来&#xff0c;通过不断递过去&#xff0c;拿回来的过程&#xff0c;将每次调用结果保存起来&#xff0c;最后实现循环调用。递归在某些情况下会极大降低我们编程的复杂度。是软件开发工程师一定要掌握的技能。 1. 概念…
阅读更多...
Linux—实操篇：vi和vim编辑器

Linux—实操篇：vi和vim编辑器

1.vi和vim基本介绍 Linux系统会内置vi文本编辑器 vim具有程序编写的能力&#xff0c;可以看做是vi的增强版本&#xff0c;被程序员广泛使用 2、vi和vim常用的三种模式 2.1、正常模式 以vim打开一个档案就直接进入一般模式了(这是默认的模式)。在这个模式中&#xff0c;你可…
阅读更多...
溯源取证 - 流量分析 中等难度

溯源取证 - 流量分析 中等难度

使用工具&#xff1a; Brim 链接: https://www.brimdata.io/download/ Networkminer 链接: https://www.netresec.com/?pageNetworkMiner Wireshark Strings ida pro 知识点&#xff1a; 通过本篇文章&#xff0c;学习ssh协议特点、学习流量导出文件、学习简单的逆向分析、…
阅读更多...
卫星定位北斗芯片AT6558一款高性能BDS/GNSS多模卫星导航接收机SOC单芯片

卫星定位北斗芯片AT6558一款高性能BDS/GNSS多模卫星导航接收机SOC单芯片

1 芯片简介 AT6558R是一款高性能BDS/GNSS多模卫星导航接收机SOC单芯片,片上集成射频前端&#xff0c; 数字基带处理器&#xff0c;32位的RISCCPU&#xff0c;电源管理功能。 芯片支持多种卫星导航系统&#xff0c;包括中国的北斗卫星导航系统BDS&#xff0c;美国的GPS,俄罗斯 的…
阅读更多...
Mysql DDL执行方式-pt-osc介绍 | 京东云技术团队

Mysql DDL执行方式-pt-osc介绍 | 京东云技术团队

1 引言 大家好&#xff0c;接着上次和大家一起学习了《MySQL DDL执行方式-Online DDL介绍》&#xff0c;那么今天接着和大家一起学习另一种MySQL DDL执行方式之pt-soc。 在MySQL使用过程中&#xff0c;根据业务的需求对表结构进行变更是个普遍的运维操作&#xff0c;这些称为…
阅读更多...
elasticsearch分词，排序，分页，高亮简单示例

elasticsearch分词，排序，分页，高亮简单示例

目录 1. 创建ES实体2. 创建查询实体3. 查询方法实现3.1 总体代码3.2 构建查询条件3.2.1 关键词分词 3.3 高亮处理4.总体查询代码 记&#xff0c;写一个简单的es分词demo,es版本6.8.12 如果使用es7有些方法可能会有所改变&#xff0c;请参考7的文档 es安装教程&#xff1a;http:…
阅读更多...
SUSE系统上安装HANA

SUSE系统上安装HANA

一：安装SUSE操作系统 1.1 准备安装镜像 SLE-15-SP1-安装程序-DVD-x86_64-GM-DVD1 SLE-15-SP1-软件包-x86_64-GM-DVD1 SAP HANA安装文件 IMDB_SERVER20_032_0-80002031.SAR 1.2 引导系统 1.3 选择要安装的产品 SUSE Linux Enterprise Server for SAP Applications 15 SP…
阅读更多...
Stable Diffusion教程(5) - 文生图教程

Stable Diffusion教程(5) - 文生图教程

配套视频教程&#xff1a; https://v.douyin.com/UyHNfYG/ 文生图界面标注如下 1 提示词和反向提示词 提示词内输入的东西就是你想要画的东西&#xff0c;反向提示词内输入的就是你不想要画的东西 提示框内只能输入英文&#xff0c;所有符号都要使用英文半角&#xff0c;词语…
阅读更多...
企业级信息系统开发讲课笔记4.5 掌握Spring Boot多环境配置

企业级信息系统开发讲课笔记4.5 掌握Spring Boot多环境配置

文章目录 零、学习目标一、项目进行多环境配置的必要性二、使用Profile文件进行多环境配置&#xff08;一&#xff09;创建Spring Boot项目&#xff08;二&#xff09;创建多环境配置文件1、全局配置文件改名2、模拟开发环境3、模拟测试环境4、模拟生产环境 &#xff08;三&…
阅读更多...
Unity基础 音频组件以及音频播放

Unity基础 音频组件以及音频播放

在游戏开发中&#xff0c;声音是一个重要的环节。Unity中的声音组件可以帮助开发者轻松地控制游戏中音频的播放、音量、循环等属性&#xff0c;从而实现更好的游戏体验。本文将详细介绍Unity声音组件的相关概念和技术&#xff0c;以及其在游戏、影视等领域的广泛应用和发展前景…
阅读更多...
银行联行号-联行号api接口-联行号数据源

银行联行号-联行号api接口-联行号数据源

接口地址&#xff1a; https://登录后显示/api/180/348(支持:http/https) 数据源&#xff1a;https://www.wapi.cn/source/8.html 网站地址&#xff1a;https://www.wapi.cn 返回格式&#xff1a;json,xml 请求方式&#xff1a;GET,POST 请求说明&#xff1a; 银行联行号-联行…
阅读更多...
数据集：T-Drive（北京出租车轨迹数据）

数据集：T-Drive（北京出租车轨迹数据）

1 数据来源 T-Drive trajectory data sample - Microsoft Research 2 数据介绍 数据集包含了2008年2月2日至2月8日期间在北京市内的10,357辆出租车的GPS轨迹。总共包含约1500万个GPS点&#xff0c;轨迹总里程达到了900万公里。 图1显示了两个连续点之间的时间间隔和距离间隔…
阅读更多...
Apache 配置和应用

Apache 配置和应用

目录 构建虚拟 Web 主机 Options指令解释 Options指令常用选项 AllowOverride指令解释&#xff1a; 地址限制策略&#xff1a; httpd服务支持的虚拟主机类型包括以下三种: 基于域名的虚拟主机 1&#xff0e;为虚拟主机提供域名解析 2.为虚拟主机准备网页文档 3.添加虚拟…
阅读更多...
【服务器】springboot实现HTTP服务监听

【服务器】springboot实现HTTP服务监听

文章目录 前言1. 本地环境搭建1.1 环境参数1.2 搭建springboot服务项目 2. 内网穿透2.1 安装配置cpolar内网穿透2.1.1 windows系统2.1.2 linux系统 2.2 创建隧道映射本地端口2.3 测试公网地址 3. 固定公网地址3.1 保留一个二级子域名3.2 配置二级子域名3.2 测试使用固定公网地址…
阅读更多...
Mysql 异常，“Cause: com.mysql.cj.jdbc.exceptions.MySQLTimeoutException”

Mysql 异常，“Cause: com.mysql.cj.jdbc.exceptions.MySQLTimeoutException”

Cause: com.mysql.cj.jdbc.exceptions.MySQLTimeoutException: Statement cancelled due to timeout or client request 简言&#xff1a;这种异常从字面翻译过来&#xff1a;mysql 请求链接超时&#xff0c;具体超时是什么原因导致的&#xff0c;可以根据情况分析下。 异常详…
阅读更多...
【黄啊码】PHP商城中的积分任务系统实现

【黄啊码】PHP商城中的积分任务系统实现

大家好&#xff0c;我是黄啊码&#xff0c;前几天有位小伙伴问我&#xff0c;商城中的任务系统是怎么实现的&#xff1f; 积分作为一种营销手段&#xff0c;被广泛运用于线上/线下的产品中&#xff0c;以此来增加用户对于产品的粘性。比如天猫积分可以用来兑换商品&#xff0c…
阅读更多...
uni-app通过vue.config.js在项目中配置跨域代理

uni-app通过vue.config.js在项目中配置跨域代理

其实这个 如果你用nginx去配肯定再好不过 不过 一般大家也都不想把开发环境弄那么复杂 最好还是在项目中配置 那么 我们选择项目跟目录右键 选择 使用命令行窗口打开所在目录 在新弹出的命令行中引入依赖 npm install http-proxy-middleware --save-dev然后我们的依赖就进来…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023