【C++】：哈希和哈希桶

朋友们、伙计们，我们又见面了，本期来给大家解读一下有关哈希和哈希桶的知识点，如果看完之后对你有一定的启发，那么请留下你的三连，祝大家心想事成！

C 语 言 专 栏：C语言：从入门到精通

数据结构专栏：数据结构

个  人  主  页 ：stackY、

C + + 专 栏   ：C++

Linux 专 栏  ：Linux

目录

1. 哈希概念

2. 哈希表的插入 

2.1 哈希冲突

2.2 哈希冲突的解决

2.2.1 闭散列（开放定址法）

2.2.2 开散列 （哈希桶/拉链法）

2.3 闭散列的代码实现

2.3.1 闭散列代码优化

2.3.2 闭散列完整代码 

2.4 开散列的代码实现 

2.4.1 开散列代码优化

2.4.2 开散列完整代码 

1. 哈希概念

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


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

2. 哈希表的插入 

1. 直接定址法

根据所要插入的关键值在哈希表中所对应的存储位置建立起的一种一 一映射关系。
这种方法所适合的场景：数据范围集中，数据量较小。

与存储位置的关系是一对一的关系，不存在哈希冲突。

2. 除留余数法

用所要插入的元素和哈希表的大小进行取模操作，这样就可以将大范围的数据缩小，根据对应关系存储在哈希表中。

这种方法所适合的场景：数据范围不集中，且数据量较多。

与存储位置的关系是多对一的关系，并且存在哈希冲突。

2.1 哈希冲突

我们经常使用除留余数法，但是会面临哈希冲突，那么什么是哈希冲突呢？

不同的关键值通过映射关系所得到的存储位置是一样的，这种情况被叫做哈希冲突或者哈希碰撞。

2.2 哈希冲突的解决

2.2.1 闭散列（开放定址法）

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

那如何寻找下一个空位置呢？


1. 线性探测

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

hashi + i (i >= 0)

2. 二次探测

从发生冲突的位置开始，依次向后探测，探测的距离是i的平方，直到寻找到下一个空位置为止。

hashi + i^2 （i >= 0） 

2.2.2 开散列 （哈希桶/拉链法）

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

从上图可以看出，开散列中每个桶中放的都是发生哈希冲突的元素。

2.3 闭散列的代码实现

1.  基本构造

为了区分哈希表中的每一个位置值的情况，所以可以设置一个枚举状态值，这个节点的状态值包含：空、存在、删除。

我们采用Key_Value结构来实现哈希表

namespace open_address
{//哈希节点状态enum Status{EMPTY,   //空EXIST,   //存在DELETE   //删除};//哈希节点template<class K, class V>struct HashData{pair<K, V> _kv;Status _s;         //哈希节点的状态};//哈希表template<class K, class V>class HashTable{public://构造HashTable(){_tables.resize(10);    //初始化先给10个空间}private:vector<HashData<K, V>> _tables;    //size_t _n = 0;                 //存储关键字的个数};
}

2. 查找 

通过传递关键之key进行查找，返回该关键值的指针，查找的逻辑首先得用key与存储位置的映射关系进行查找，如果查找到了空还没有找到对应的关键值，那么就返回空，映射关系我们采用的是除留余数法。

那么为什么找到空就结束了呢？首先我们根据除留余数法找到key存储的位置，那么这个位置有可能是被哈希冲突所占用的位置，那么本该存储在这个位置的值就需要继续向后面找空位置填充上去，那么key这个值的前面的位置的状态都是存在，所以可以一直向后面找，直到为空就停止。

	//查找HashData<K, V>* Find(const K& key){size_t hashi = key % _tables.size();  //找对应位置//不为空继续查找while (_tables[hashi]._s != EMPTY){if (_tables[hashi]._s == EXIST&&_tables[hashi]._kv.first == key)     //_kv.first存在且等于key表示找到了{return &_tables[hashi];}++hashi;hashi %= _tables.size();}return NULL;}

3. 插入

插入首先需要查找要插入的key有没有在表中存在，若不存在既可以插入，若存在则不能插入。

插入我们采用除留余数法，用key与表的大小取模得到的映射关系，如果映射到的的位置的状态是存在，那么就需要继续向后面找空余的位置，如果映射到的位置的状态是删除或者空，那么就可以插入，如果映射到的位置后面的空间已满，那么就与表的大小取模，从最前面开始找空余位置。

//插入bool Insert(const pair<K, V>& kv){//先查找if (Find(kv.first))return false;//线性探测size_t hashi = kv.first % _tables.size();  //找到对应的映射while (_tables[hashi]._s == EXIST){hashi++;                     //找到后面空着的位置hashi %= _tables.size();     //形成一个圈}  _tables[hashi]._kv = kv;            //插入_tables[hashi]._s = EXIST;      //修改状态++_n;                           //关键字个数++return true;}

写到这里，那么存在一个问题，如果空间满了就需要扩容，那么哪种方式的扩容最容易呢？

可以使用在模拟实现string时，string的拷贝构造的现代写法，那么这种现代写法怎么运用到哈希表中呢？

首先要设置一个负载因子，表示空间使用率，这个负载因子我们设置为百分之70，如果使用率超过了百分之70，我们就需要进行扩容，扩容我们采用2倍扩容的方式，首先将创建一个新的哈希表，大小为原来表的2倍，然后依次遍历旧表，将旧表中的数据依次插入到新表，这时，新的哈希表就是我们想要的，然后将它与旧表交换即可，然后将新表删除即可。

//插入bool Insert(const pair<K, V>& kv){//先查找if (Find(kv.first))return false;//负载因子设置为0.7if (_n * 10 / _tables.size() == 7){//扩容size_t NewSize = _tables.size() * 2;   //2倍扩容HashTable<K, V> NewHash;               //创建新的哈希表NewHash._tables.resize(NewSize);       //设置为原来2倍大小//遍历旧表将旧表中的内容插入新表for (int i = 0; i < _tables.size(); ++i){if (_tables[i] == EXIST){NewHash.Insert(_tables[i]._kv);}}//交换_tables.swap(NewHash._tables);}//线性探测size_t hashi = kv.first % _tables.size();  //找到对应的映射while (_tables[hashi]._s == EXIST){hashi++;                     //找到后面空着的位置hashi %= _tables.size();     //形成一个圈}  _tables[hashi]._kv = kv;            //插入_tables[hashi]._s = EXIST;      //修改状态++_n;                           //关键字个数++return true;}

新表是一个局部变量，出了作用域自动调用它的析构函数，析构函数内置类型不做处理，自定义类型vector会去自动调用vector的析构函数。

4. 删除

这里采用的是伪删除的方法，首先找到需要删除的key，然后将其对应的状态改为删除即可，然后将关键值个数减一。

//伪删除法bool Erase(const K& key){HashData<K, V>* ret = Find(key);if (ret){ret->_s = DELETE;          //修改状态即可_n--;                      //个数--return true;            }elsereturn false;}

2.3.1 闭散列代码优化

上述代码能看到很明显的局限性，我们在取模的时候给的是整型，但是遇到浮点类型、string类型就不能进行取模操作了，因此需要优化一下，利用仿函数，对与浮点数进行类型强转，然后特化出一份专门处理string类型的，可以将string类型的字符串所有字符的ASCII码加起来进行映射操作。

//仿函数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& s){size_t ret = 0;for (auto e : s){ret *= 31;  //防止字符一样顺序不一样ret += e;   //字符ASCII加起来}return ret;}};

2.3.2 闭散列完整代码 

#pragma once
#include <vector>//开放定址法
namespace open_address
{//仿函数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& s){size_t ret = 0;for (auto e : s){ret *= 31;  //防止字符一样顺序不一样ret += e;   //字符ASCII加起来}return ret;}};//哈希节点状态enum Status{EMPTY,   //空EXIST,   //存在DELETE   //删除};//哈希节点template<class K, class V>struct HashData{pair<K, V> _kv;Status _s;         //哈希节点的状态};//哈希表template<class K, class V, class Hash = HashFunc<K>>class HashTable{public://构造HashTable(){_tables.resize(10);    //初始化先给10个空间}//插入bool Insert(const pair<K, V>& kv){//先查找if (Find(kv.first))return false;//负载因子设置为0.7if (_n * 10 / _tables.size() == 7){//扩容size_t NewSize = _tables.size() * 2;   //2倍扩容HashTable<K, V> NewHash;               //创建新的哈希表NewHash._tables.resize(NewSize);       //设置为原来2倍大小//遍历旧表将旧表中的内容插入新表for (size_t i = 0; i < _tables.size(); ++i){if (_tables[i]._s == EXIST){NewHash.Insert(_tables[i]._kv);}}//交换_tables.swap(NewHash._tables);}//仿函数Hash hs;//线性探测size_t hashi = hs(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 hs;size_t hashi = hs(key) % _tables.size();  //找对应位置//不为空继续查找while (_tables[hashi]._s != EMPTY){if (_tables[hashi]._s == EXIST&&_tables[hashi]._kv.first == key)     //_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;            }elsereturn false;}private:vector<HashData<K, V>> _tables;    //size_t _n = 0;                 //存储关键字的个数};
}

2.4 开散列的代码实现 

1. 基本构造

开散列又叫做哈希桶，这些桶也就是单链表所链接的节点，将存在哈希冲突的都放在同一个桶中，那么也避免不了冲突过多导致一个桶过长，因此，在部分编程语言中规定了如果一个桶的长度超过了8，那么就将原来挂的单链表转挂成红黑树。由于存在哈希思想，所以哈希桶的平均时间复杂度是O(1)。

同样的我们采用Key_Value的结构来定义哈希节点和哈希表，那么关于哈希表的实现我们可以采用两种方法：

① 使用库中的forward_list来现用，并且还可以根据桶的长度加上红黑树（吃现成）

namespace hash_bucket
{template<class K, class T>class HashTable{private:struct bucket{forwad_list<pair<K, V>> _lt;   //单链表set<pair<K, V>> _rbtree;       //红黑树size_t len = 0; // 超过8，放到红黑树};vector<bucket> _tables;int _n;};
}

② 我们自己实现桶的节点（方便封装迭代器）

namespace hash_bucket
{template<class K, class T>class HashNode{HashNode(const pair<K, T>& kv):_kv(kv),_next(nullptr){}pair<K, T> _kv;HashNode* _next;};template<class K, class T>class HashTable{public:HashTable(){_tables.resize(10);}public:typedef HashNode<K, T> Node;private:vector<Node*> _tables;size_t _n;};
}

我们采用第二种方法实现，便于后面封装unordered_set和unordered_map。

2. 查找

首先用key取模哈希表的大小，从而找到hashi确定在哪个桶，然后再遍历该桶找key

//查找Node* Find(const K& key){//确定在哪一个桶中size_t hashi = key % _tables.size();Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key)return cur;else cur = cur->_next;}return nulptr;}

3. 插入

哈希桶的插入需要借助于Find，如果这个桶里面存在相同的数据，则不能插入（类似于set机制），如果没有方可插入，哈希桶的负载因子我们一般设置为1，那么哈希桶的插入有两种：尾插和头插，两种方式均可以插入，因为尾插需要找尾，所以我们一般选择头插。

那么该怎么对哈希桶进行扩容呢？

可以参考在实现闭散列时的方法：先创建一个容量为旧表容量二倍的新表，采用的遍历旧表将哈希桶中的节点头插到新表的映射位置，然后将旧表与新表实现交换，这样就拿到了新表的数据，也就完成了扩容的操作。

注意：虽然将旧表的桶挪到新表中，但是旧表中的节点还是指向该桶，所以每挪完一个桶需要将旧表的节点置为nullptr。

//插入
bool Insert(const pair<K, T>& kv)
{if (Find(kv.first))return false;//扩容//负载因子为1再扩容if (_n == _tables.size()){//创建新的哈希表vector<Node*> newTables;newTables.resize(_tables.size() * 2, nullptr);//遍历旧表for (int i = 0; i < _tables.size(); i++){//将旧表的节点依次遍历插入到新表Node* cur = _tables[i];while (cur){Node* next = cur->_next;      //记录下一个节点size_t hashi = cur->kv.first % newTables.size();  //找到在新表里面的映射cur->_next = newTables[hashi];  //链接newTables[hashi] = cur;cur = next;   //找下一个}_tables[i] = nullptr;  //断开链接}_tables.swap(newTables);   //拿到新表的数据}//头插size_t hashi = kv.first % _tables.size();Node* newnode = new Node(kv);newnode->_next = _tables[hashi];_tables[hashi] = newnode;_n++;return true;
}

4. 删除

先通过key的映射查看在哪个桶中，然后遍历该桶，将需要删除的节点的前一个节点prev的next指向要删除节点的下一个节点，然后delete该节点即可完成删除，这个过程需要注意如果prev为空，那么直接将_tables[hashi]指向要删除节点的下一个节点即可。

//删除
bool Erease(const K& key)
{size_t hashi = key % _tables.size();Node* cur = _tables[hashi];Node* prev = nullptr;while (cur){if (cur->_kv.first == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;delete cur;return true;}}prev = cur;cur = cur->_next;}return false;
}

5. 析构函数

由于我们自主实现了一个单链表，所以在析构时需要我们手动的进行释放哈希桶中的一系列节点。

~HashTable()
{//手动释放哈希桶//遍历哈希表依次释放桶中的节点for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}
}

2.4.1 开散列代码优化

根据闭散列的经验，我们还需要给开散列也同样的设置转化整数的仿函数，防止string类型不能转化为整数的缺陷，那么同样的需要用到模板特化，在浮点数转化整型的基础上特化一份转化string类型的仿函数。

//仿函数
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& s){size_t ret = 0;for (auto e : s){ret *= 31;  //防止字符一样顺序不一样ret += e;   //字符ASCII加起来}return ret;}
};

2.4.2 开散列完整代码 

    // 开散列
namespace hash_bucket
{//仿函数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& s){size_t ret = 0;for (auto e : s){ret *= 31;  //防止字符一样顺序不一样ret += e;   //字符ASCII加起来}return ret;}};template<class K, class T>class HashNode{public:HashNode(const pair<K, T>& kv):_kv(kv),_next(nullptr){}pair<K, T> _kv;HashNode* _next;};template<class K, class T, class Hash = HashFunc<K>>class HashTable{public:HashTable(){_tables.resize(10);}~HashTable(){//手动释放哈希桶//遍历哈希表依次释放桶中的节点for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}public:typedef HashNode<K, T> Node;Hash hf;  //仿函数用于转化整型//查找Node* Find(const K& key){size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (cur->_kv.first == key)return cur;else cur = cur->_next;}return nullptr;}//插入bool Insert(const pair<K, T>& kv){if (Find(kv.first))return false;//扩容//负载因子为1再扩容if (_n == _tables.size()){//创建新的哈希表vector<Node*> newTables;newTables.resize(_tables.size() * 2, nullptr);//遍历旧表for (size_t i = 0; i < _tables.size(); i++){//将旧表的节点依次遍历插入到新表Node* cur = _tables[i];while (cur){Node* next = cur->_next;      //记录下一个节点size_t hashi = hf(cur->_kv.first) % newTables.size();  //找到在新表里面的映射cur->_next = newTables[hashi];  //链接newTables[hashi] = cur;cur = next;   //找下一个}_tables[i] = nullptr;  //断开链接}_tables.swap(newTables);   //拿到新表的数据}//头插size_t hashi = hf(kv.first) % _tables.size();Node* newnode = new Node(kv);newnode->_next = _tables[hashi];_tables[hashi] = newnode;_n++;return true;}//删除bool Erase(const K& key){size_t hashi = hf(key) % _tables.size();Node* cur = _tables[hashi];Node* prev = nullptr;while (cur){if (cur->_kv.first == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;delete cur;return true;}}prev = cur;cur = cur->_next;}return false;}private:vector<Node*> _tables;size_t _n;};
}

朋友们、伙计们，美好的时光总是短暂的，我们本期的的分享就到此结束，欲知后事如何，请听下回分解~，最后看完别忘了留下你们弥足珍贵的三连喔，感谢大家的支持！    

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

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

相机图像质量研究(18)常见问题总结：CMOS期间对成像的影响--CFA

相机图像质量研究(18)常见问题总结：CMOS期间对成像的影响--CFA

系列文章目录 相机图像质量研究(1)Camera成像流程介绍 相机图像质量研究(2)ISP专用平台调优介绍 相机图像质量研究(3)图像质量测试介绍 相机图像质量研究(4)常见问题总结&#xff1a;光学结构对成像的影响--焦距 相机图像质量研究(5)常见问题总结&#xff1a;光学结构对成…
阅读更多...
Linux系统入门

Linux系统入门

目录 探索命令行 学习使用 man 寻找帮助 控制字符 统计代码行数 统计磁盘使用情况 在Linux下编写 Hello World 程序 使用重定向 使用Makefile管理工程 Unix哲学 探索命令行 Linux命令行中的命令使用格式都是相同的: 命令名称 参数1 参数2 参数3 ... 参数之间用任意…
阅读更多...
.NET Core WebAPI中封装Swagger配置

.NET Core WebAPI中封装Swagger配置

一、创建相关文件 创建一个Utility/SwaggerExt文件夹&#xff0c;添加一个类 二、在Program中找到Swagger相关配置信息 三、添加方法&#xff0c;在Program中调用 在SwaggerExt类中添加方法&#xff0c;将相关配置添写入 /// <summary> /// swagger配置 /// </sum…
阅读更多...
ORB-SLAM 三角化

ORB-SLAM 三角化

特征点三角化(Triangulation)是是双目视觉中一个基础算法&#xff0c;也是VSLAM中一个非常基础的问题,它是根据特征点在多个相机下的投影恢复出特征点的3D坐标。 使用SVD求解方程组。
阅读更多...
为什么需要关注差分阻抗

为什么需要关注差分阻抗

差分对的主要目的是为了保持正确的差分阻抗&#xff0c;因此&#xff0c;必须了解差分阻抗的含义&#xff0c;差分阻抗是每条走线奇模阻抗的两倍&#xff0c;而每条走线的单端阻抗&#xff08;SE, single-ended&#xff09;&#xff0c;仅当差分线内没有对内耦合时&#xff0c;…
阅读更多...
红色警戒 3 修改游戏速度

红色警戒 3 修改游戏速度

原文&#xff1a;https://blog.iyatt.com/?p13852 红警 2 是有提供游戏速度修改的&#xff0c;红警 3 没有&#xff0c;而且游戏速度似乎和 FPS 关联的&#xff0c;在配置低一些的电脑上会变慢&#xff0c;FPS 也降低&#xff0c;我电脑上开最高画质 FPS 不超过 30&#xff0c…
阅读更多...
SAP PP学习笔记- 豆知识03 - 品目的外部购买发注（购买发注）和内部购买发注（內制）的控制

SAP PP学习笔记- 豆知识03 - 品目的外部购买发注（购买发注）和内部购买发注（內制）的控制

其实也是在品目类型的Customize里面。 Customize上的设置如何影响界面。其实挺复杂的&#xff0c;一点点来吧。 1&#xff0c;外部购买发注 外部购买发注就是咱们认识的购买发注。 - 0 外部购买发注不可 - 1 外部购买发注可&#xff08;有警告Message&#xff09; - 2 外部…
阅读更多...
书生浦语大模型实战营-课程作业（3）

书生浦语大模型实战营-课程作业（3）

下载sentence_transformer的代码运行情况。sentence_transformer用于embedding&#xff08;转向量&#xff09; 本地构建持久化向量数据库。就是把txt和md文件抽取出纯文本&#xff0c;分割成定长&#xff08;500&#xff09;后转换成向量&#xff0c;保存到本地&#xff0c;称…
阅读更多...
Java中的Stack的基本讲解

Java中的Stack的基本讲解

目录 一、创建栈 二、Stack的一些常用方法 对于栈的基本概念,我就不细说了&#xff0c;后进先出。比如1,2,3,依次进栈&#xff0c;那么出栈就是3&#xff0c;2&#xff0c;1。 一、创建栈 Stack<引用数据类型&#xff0c;基本数据类使用包装类> snew Stack<>();St…
阅读更多...
【BUUCTF 加固题】Ezsql 速通

【BUUCTF 加固题】Ezsql 速通

&#x1f36c; 博主介绍&#x1f468;‍&#x1f393; 博主介绍&#xff1a;大家好&#xff0c;我是 hacker-routing &#xff0c;很高兴认识大家~ ✨主攻领域&#xff1a;【渗透领域】【应急响应】 【Java】 【VulnHub靶场复现】【面试分析】 &#x1f389;点赞➕评论➕收藏 …
阅读更多...
ubuntu22.04@laptop OpenCV Get Started: 010_blob_detection

ubuntu22.04@laptop OpenCV Get Started: 010_blob_detection

ubuntu22.04laptop OpenCV Get Started: 010_blob_detection 1. 源由2. blob应用Demo2.1 C应用Demo2.2 Python应用Demo 3. 重点分析3.1 Threshold3.2 Area3.3 Circularity3.4 Convexity3.5 Inertia Ratio 4. 总结5. 参考资料6. 补充 1. 源由 Blob是图像中的一组连接像素&#…
阅读更多...
Dynamo处理点云数据

Dynamo处理点云数据

Hello大家好&#xff01;我是九哥~ 随着三维激光点云扫描技术的推广&#xff0c;越来越多的项目中应用到了三维激光点云扫描。基于三维点云数字化模型&#xff0c;在建筑工程项目设计、施工和改造等过程中&#xff0c;能够完成实测实量、偏差检测、变形监测、模型对比、场地构建…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023