C++实现哈希表。

原创 已于 2023-08-22 11:40:08 修改 · 6.8k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #散列表 #数据结构

于 2022-11-17 10:16:22 首次发布
本文介绍了C++中unordered_map、unordered_set与map、set的区别，并深入探讨哈希表，包括哈希函数、哈希冲突及其解决方法——闭散列和开散列，详细解析了两种方法的实现、负载因子以及它们在性能和空间使用上的考量。

目录

一. unordered_map unordered_set 和 map set的区别

二. 哈希

1. 哈希，哈希表，哈希函数。

2. 哈希冲突。

3. 哈希函数补充

3. 解决哈希冲突的两大方法：闭散列，开散列

闭散列

闭散列实现代码：

闭散列的删除问题：

负载因子：

开散列：

开散列哈希表代码实现：

开散列的负载因子和扩容问题：

开散列和闭散列的比较：

一. unordered_map unordered_set 和 map set的区别

1. map set底层采取的红黑树的结构，unordered_xxx 底层数据结构是哈希表。unordered_map容器通过key访问单个元素要比map快，但它通常在遍历元素子集的范围迭代方面效率较低。

2. Java中对应的容器名为 HashMap HashSet TreeMap TreeSet，命名方面比C++好了很多。主要是早期C++并没有实现哈希结构的容器（C++11之前），也就是unordered系列，在C++11中新增了unordered_map，unordered_set，unordered_multimap，unordered_multiset，故因为历史命名问题，取了这样的名字。

3. 它们的使用大体上几乎一致。显著的差别是：
a、map和set为双向迭代器，unordered_xxx和是单向迭代器。
b、map和set存储为有序存储（红黑树结构，中序遍历有序），unordered_xxx为无序存储（哈希表的结构致使）

4. 性能差异：采取哈希表的unordered系列容器在大量数据的增删查改效率更优，尤其是查（搜索）

二. 哈希

1. 哈希，哈希表，哈希函数。

哈希的思想是：将元素的关键码与元素在哈希表中的存储位置构建某种函数关系，使得查找时，可以通过这个函数，直接获取元素的存储位置。对比顺序表和搜索树，顺序表需要将关键码一一对比，时间复杂度为O(N)，而搜索树这样的结构，时间复杂度也是(log_2 N)，取决于元素个数，树的高度，同样需要若干次比较。而哈希可以使得查找元素的存储位置不需要比较，直接通过函数获取。

将这个转换函数成为哈希函数（散列函数），得到的元素的存储位置成为哈希地址（也就是在哈希表中的下标，哈希表一般为顺序表结构），将构造出的数据结构成为哈希表（散列表）。

2. 哈希冲突。

难免有某些元素的不同关键码通过同一个哈希函数转换后得到的哈希地址相同，这种现象称为哈希冲突或哈希碰撞。

故，要想构造出理想的哈希存储结构，必须解决哈希冲突，合理安排那些关键码不同，而哈希地址相同的元素。

3. 哈希函数补充

哈希函数有很多种，也就是将元素的关键码，转换为元素存储位置的函数。哈希函数的设计越精妙，产生哈希冲突的概率越低，但是无法完全避免哈希冲突。

下方哈希表的实现代码中，采取的哈希函数为除留余数法，即将关键码取模哈希表的长度，获取哈希地址。

3. 解决哈希冲突的两大方法：闭散列，开散列

闭散列

闭散列：也叫开放定址法。核心思想比较简单：若某两个元素发生哈希冲突，第二个得到该哈希地址的元素插入时，将该元素存放到哈希表中发生哈希冲突的“下一个”空位置中去。其实也就是再找一个空位置，然后插入。

如何寻找下一个“空位置”的方法有两种，1. 线性探测，即从哈希地址处起，逐个位置进行判断，直到找到空位置。2. 二次探测：第一次看hashAdd+0^2下标处有没有被占用（设哈希地址为hashAdd。其实也就是看获取的哈希地址处有没有没被占用），第二次看hashAdd+1^2，第三次看hashAdd+2^2，直到找到没有被占用的位置。

相比于线性探测，二次探测只是将发生哈希冲突的元素的存储位置分离一些，不像线性探测一样连续存储，能一定程度减少哈希冲突带来的性能损耗，但是不能根本解决问题。

闭散列实现代码：

// 开散列（链地址法）解决哈希表中的哈希冲突
namespace OpenHashing
{
    // 这里仅仅是实现哈希表的最简单逻辑，Find等函数的实现没有考虑unordered_map等容器
    template <class K, class V>
    struct HashNode
    {
        HashNode<K,V>(const pair<K,V>& kv)
        :_kv(kv)
        { }
        pair<K, V> _kv;
        HashNode* _next = nullptr;
    };

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

    // 模板特化
    template <>
    struct HashAddressConvert<string>
    {
        size_t operator()(const string& str) {
            size_t sum = 0;
            for(auto&ch:str)
            {
                sum*=131;
                sum+=ch;
            }
            return sum;
        }
    };

    template <class K, class V, class HDC = HashAddressConvert<K>>
    class HashTable
    {
        typedef HashNode<K, V> Node;
    public:
        ~HashTable() {
            for(auto& ptr : _table) {
                Node* cur = ptr;
                while(cur) {
                    Node* next = cur->_next;
                    delete cur;
                    cur = next;
                }
                ptr = nullptr;
            }
        }
        bool Insert(const pair<K, V>& kv) {
            if(Find(kv.first)) {
                return false;
            }
            HDC convert;
            if(_table.size() == 0 || 10 * _size / _table.size() >= 10) {
                // 开散列法哈希表扩容
                vector<Node*> newTable;
                size_t newSize = _table.size() == 0 ? 10 : _table.size()*2;
                newTable.resize(newSize);
                for(size_t i = 0; i < _table.size(); ++i) {
                    Node* cur = _table[i];
                    while(cur) {
                        Node* next = cur->_next;
                        size_t hashAddress = convert(cur->_kv.first) % newTable.size();
                        cur->_next = newTable[hashAddress];
                        newTable[hashAddress] = cur;
                        cur = next;
                    }
                    _table[i] = nullptr;
//                    if(_table[i]) {
//                        Node* cur = _table[i];
//                        Node* next = cur->_next;
//                        while(cur) {
//                            size_t hashAddress = convert(cur->_kv.first) % newTable.size();
//                            cur->_next = newTable[hashAddress];
//                            newTable[hashAddress] = cur;
//                            cur = next;
//                            if(cur)
//                                next = cur->_next;
//                        }
//                        // 也没必要其实
//                        _table[i] = nullptr;
//                    }
                }
                _table.swap(newTable);
            }
            // 通过哈希函数求哈希地址
            size_t hashAddress = convert(kv.first) % _table.size();
            Node* ptr = _table[hashAddress];
            Node* newNode = new Node(kv);
            // 每个哈希桶中进行头插
            newNode->_next = ptr;
            _table[hashAddress] = newNode;
            ++_size;
            return true;
        }

        Node* Find(const K& key) {
            if(_table.size() == 0) {
                return nullptr;
            }
            HDC convert;
            size_t hashAddress = convert(key) % _table.size();
            Node* cur = _table[hashAddress];
            while(cur) {
                if(cur->_kv.first == key) {
                    return cur;
                }
                cur = cur->_next;
            }
            return nullptr;
        }

        bool Erase(const K& key) {
            if(_table.size() == 0)
                return false;
            HDC convert;
            size_t hashAddress = convert(key) % _table.size();
            Node* cur = _table[hashAddress];
            Node* prev = nullptr;
            while(cur) {
                if(cur->_kv.first == key) {
                    if(prev)
                        prev->_next = cur->_next;
                    else
                        _table[hashAddress] = cur->_next;
                    delete cur;
                    --_size;
                    return true;
                }
                prev = cur;
                cur = cur->_next;
            }
            // 不存在该节点
            return false;
        }

        // 哈希表的长度
        size_t TableSize() {
            return _table.size();
        }

        // 非空哈希桶的个数
        size_t BucketNum() {
            size_t num = 0;
            for(auto&ptr:_table) {
                if(ptr)
                    num++;
            }
            return num;
        }

        // 哈希表中数据的个数
        size_t Size() {
            return _size;
        }

        // 最大的桶的长度
        size_t MaxBucketLength() {
            size_t max = 0;
            for(size_t i = 0; i < _table.size(); ++i) {
                size_t len = 0;
                Node* ptr = _table[i];
                while(ptr)
                {
                    len++;
                    ptr = ptr->_next;
                }
                if(len > max)
                    max = len;
//                if (len > 0)
//                    printf("[%d]号桶长度:%d\n", i, len);
            }
            return max;
        }
    private:
        vector<HashNode<K, V>*> _table;
        size_t _size = 0;
    };

}

闭散列的删除问题：

如上哈希表中，关键值4和44采取除留余数法哈希函数获取的哈希地址相同，都是4，最后插入44时，向后找空位置，无论是线性探测还是二次探测，都会插入到哈希表中哈希地址（下标）为8处。

此时，若删除5（或者4，6，7），再查找44，就会影响44的查找，故在闭散列的哈希表实现中，哈希表中每个存储位置的存储状态，包括：存在EXIST，删除DELETE，空EMPTY。查找44时，不能因为5位置为空就停止线性探测查找，也就是遇到DELETE不停。（看代码）。线性探测采用标记的伪删除法来删除一个元素。

负载因子：

负载因子为哈希表中的元素个数/哈希表长度。

负载因子越大，同样长度的哈希表存储的元素越多，发生哈希冲突概率越大，查找时效率越低，但是空间使用率越高。

负载因子越小，同样长度的哈希表存储的元素越少，发生哈希冲突概率越小，查找时效率越高，但是空间使用率越低。

理论上，采取闭散列的哈希表的最大负载因子为1，负载因子为1时必须扩容。但是，闭散列哈希表当负载因子超过0.8时，查表时CPU缓存不命中按照指数曲线上升。故，负载因子需要取一个合适的值，对于闭散列（开放定址法）的哈希表，负载因子非常重要，应控制在0.7 ~ 0.8以下，若超出，即需要扩容哈希表。

开散列：

开散列是另一种解决哈希冲突的方法。核心思想是：首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码（发生哈希冲突）归于同一子集合，每一个子集合称为一个哈希桶，各个桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中。

哈希表代码实现中，哈希表数组存储的是结点指针（结点封装数据和单链表next指针）。

开散列的哈希表中每个哈希桶存放的都是发生哈希冲突的元素。

开散列哈希表代码实现：

// 开散列（链地址法）解决哈希表中的哈希冲突
namespace OpenHashing
{
    // 这里仅仅是实现哈希表的最简单逻辑，Find等函数的实现没有考虑unordered_map等容器
    template <class K, class V>
    struct HashNode
    {
        HashNode<K,V>(const pair<K,V>& kv)
        :_kv(kv)
        { }
        pair<K, V> _kv;
        HashNode* _next = nullptr;
    };

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

    // 模板特化
    template <>
    struct HashAddressConvert<string>
    {
        size_t operator()(const string& str) {
            size_t sum = 0;
            for(auto&ch:str)
            {
                sum*=131;
                sum+=ch;
            }
            return sum;
        }
    };

    template <class K, class V, class HDC = HashAddressConvert<K>>
    class HashTable
    {
        typedef HashNode<K, V> Node;
    public:
        ~HashTable() {
            for(auto& ptr : _table) {
                Node* cur = ptr;
                while(cur) {
                    Node* next = cur->_next;
                    delete cur;
                    cur = next;
                }
                ptr = nullptr;
            }
        }
        bool Insert(const pair<K, V>& kv) {
            if(Find(kv.first)) {
                return false;
            }
            HDC convert;
            if(_table.size() == 0 || 10 * _size / _table.size() >= 10) {
                // 开散列法哈希表扩容
                vector<Node*> newTable;
                size_t newSize = _table.size() == 0 ? 10 : _table.size()*2;
                newTable.resize(newSize);
                for(size_t i = 0; i < _table.size(); ++i) {
                    Node* cur = _table[i];
                    while(cur) {
                        Node* next = cur->_next;
                        size_t hashAddress = convert(cur->_kv.first) % newTable.size();
                        cur->_next = newTable[hashAddress];
                        newTable[hashAddress] = cur;
                        cur = next;
                    }
                    _table[i] = nullptr;
//                    if(_table[i]) {
//                        Node* cur = _table[i];
//                        Node* next = cur->_next;
//                        while(cur) {
//                            size_t hashAddress = convert(cur->_kv.first) % newTable.size();
//                            cur->_next = newTable[hashAddress];
//                            newTable[hashAddress] = cur;
//                            cur = next;
//                            if(cur)
//                                next = cur->_next;
//                        }
//                        // 也没必要其实
//                        _table[i] = nullptr;
//                    }
                }
                _table.swap(newTable);
            }
            // 通过哈希函数求哈希地址
            size_t hashAddress = convert(kv.first) % _table.size();
            Node* ptr = _table[hashAddress];
            Node* newNode = new Node(kv);
            // 每个哈希桶中进行头插
            newNode->_next = ptr;
            _table[hashAddress] = newNode;
            ++_size;
            return true;
        }

        Node* Find(const K& key) {
            if(_table.size() == 0) {
                return nullptr;
            }
            HDC convert;
            size_t hashAddress = convert(key) % _table.size();
            Node* cur = _table[hashAddress];
            while(cur) {
                if(cur->_kv.first == key) {
                    return cur;
                }
                cur = cur->_next;
            }
            return nullptr;
        }

        bool Erase(const K& key) {
            if(_table.size() == 0)
                return false;
            HDC convert;
            size_t hashAddress = convert(key) % _table.size();
            Node* cur = _table[hashAddress];
            Node* prev = nullptr;
            while(cur) {
                if(cur->_kv.first == key) {
                    if(prev)
                        prev->_next = cur->_next;
                    else
                        _table[hashAddress] = cur->_next;
                    delete cur;
                    --_size;
                    return true;
                }
                prev = cur;
                cur = cur->_next;
            }
            // 不存在该节点
            return false;
        }

        // 哈希表的长度
        size_t TableSize() {
            return _table.size();
        }

        // 非空哈希桶的个数
        size_t BucketNum() {
            size_t num = 0;
            for(auto&ptr:_table) {
                if(ptr)
                    num++;
            }
            return num;
        }

        // 哈希表中数据的个数
        size_t Size() {
            return _size;
        }

        // 最大的桶的长度
        size_t MaxBucketLength() {
            size_t max = 0;
            for(size_t i = 0; i < _table.size(); ++i) {
                size_t len = 0;
                Node* ptr = _table[i];
                while(ptr)
                {
                    len++;
                    ptr = ptr->_next;
                }
                if(len > max)
                    max = len;
//                if (len > 0)
//                    printf("[%d]号桶长度:%d\n", i, len);
            }
            return max;
        }
    private:
        vector<HashNode<K, V>*> _table;
        size_t _size = 0;
    };
}

开散列的负载因子和扩容问题：

注意：哈希表是需要扩容的，而是否扩容的衡量指标就是负载因子。

开散列中，当负载因子为1时，也就是理想情况下每个哈希桶中只挂一个元素时，进行扩容。因为再继续插入元素时，每一次都会发生哈希冲突，而开散列哈希表中若一个桶中的元素个数比较多时，会影响哈希表的性能。理想情况就是每个哈希桶中只挂一个元素，此时搜索时间复杂度为O(1)。

开散列和闭散列的比较：

应用链地址法处理哈希冲突，需要增设链接指针，似乎增加了存储开销。事实上： 由于开地址法必须保持大量的空闲空间以确保搜索效率，如二次探查法要求装载因子a <= 0.7，而表项所占空间又比指针大的多，所以使用链地址法反而比开地址法节省存储空间。

C++ 哈希表
Han同学
02-26 4983
C++哈希表
【C++】哈希表
m0_63852285的博客
05-07 2119
散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。unordered_map是存储键值对的关联式容器，其允许通过keys快速的索引到与其对应的value。在unordered_map中，键值通常用于惟一地标识元素，而映射值是一个对象，其内容与此键关联。
C++：哈希表
最新发布
2401_87353862的博客
11-04 850
本文系统介绍了哈希技术的核心概念与实现方法，重点分析了开放定址法的实现逻辑。哈希技术通过哈希函数将任意长度输入转换为固定长度输出，主要应用于快速映射、查找和去重。文章详细阐述了哈希表的核心构成（桶数组、哈希函数、冲突解决机制）、负载因子特性（空间利用率与冲突概率的平衡）以及三种哈希函数设计方法（除法散列法、乘法散列法、全域散列法）。针对开放定址法，深入解析了其线性探测的定位规则和群集现象问题，并通过C++代码示例展示了扩容机制和元素迁移的巧妙实现。最后强调了哈希函数设计和冲突处理方法在实际应用中的重要性，为
模拟实现哈希表超详解（C++）
m0_67430750的博客
05-15 7589
模拟实现哈希表两万字详解，包括哈希表的闭散列实现和开散列实现，以及迭代器的实现。
Hash表（C++实现）
lovecontry
08-20 599
哈希表的几个概念： 映像：由哈希函数得到的哈希表是一个映像。 冲突：如果两个关键字的哈希函数值相等，这种现象称为冲突。 处理冲突的几个方法： 1、开放地址法：用开放地址处理冲突就是当冲突发生时，形成一个地址序列，沿着这个序列逐个深测，直到找到一个“空”的开放地址，将发生冲突的关键字值存放到该地址中去。 例如：hash(i)=(hash(key)+d(i)) MOD m (i=1,2,3,...
哈希表(C++实现)
m0_50655389的博客
07-01 2438
可以不经过任何比较，一次直接从表中得到要搜索的元素
C++ 实现哈希表的实例
08-29
C++ 实现哈希表的实例详解 哈希表是一种常用的数据结构，它可以快速地存储和检索数据。在 C++ 中，实现哈希表的实例可以帮助我们更好地理解哈希表的原理和实现机制。下面我们将详细介绍 C++ 实现哈希表的实例的相关...
C++实现哈希表教程与源码解析
在使用C++实现哈希表时，可以利用结构体和类来定义键值对和哈希表本身。例如，可以创建一个`pair`类型的结构体来存储键值对，然后创建一个哈希表类，其中包含数组、哈希函数和冲突解决机制等组件。此外，还需要实现...
C++实现哈希表设计实验报告
### C++实现哈希表 在C++中，可以使用模板类来设计一个通用的哈希表。下面是一些关键点： 1. **模板设计**：通过模板（template）实现一个通用哈希表，可以存储任意类型的数据。 2. **数组操作**：哈希表底层是...
【C++】哈希表实现
uyeonashi的博客
12-21 1540
当key是string/Date等类型时，key不能取模，那么我们需要给HashTable增加一个仿函数，这个仿函数支持把key转换成一个可以取模的整形，如果key可以转换为整形并且不容易冲突，那么这个仿函数就用默认参数即可，如果这个Key不能转换为整形，我们就需要自己实现一个仿函数传给这个参数，实现这个仿函数的要求就是尽量key的每值都参与到计算中，让不同的key转换出的整形值不同。，那么计算出的哈希值都是15，因为63的二进制后8位是 00111111，31的二进制后8位是 00011111。
一个c++实现的哈希表类
06-27
在程序中我们对关键字key应用散列函数H(key)来判断关键字key是否在散列表中，即计算H(key)的值，H(key)值确定所存数据在散列表中的位置。这样一个数据元素的地址是通过函数来计算的，所以数据元素并不需要按照特定的顺序来存放。但是散列函数H(key)将关键字映射为一个整数时，有可能两个关键字的地址相同，所以构造散列函数时要考虑尽量减少冲突的发生。构造散列函数有多种方法，如：平方取中法、除留余数随机数法。本程序采用除留余数法。程序的具体实现如下：本程序是用模板类myhash来实现，包括protected和public属性成员。其中protected成员有*ht（自定义散列表指针）、*empty(bool类型指针，功能是将元素值空、m(散列表容量)、p(除留余数法的除数)以及辅助函数H(key)(散列函数)和collision(处理冲突的函数)；public成员包括构造函数、析构函数和复制构造函数以及=重载函数，其它成员函数主要有：traver(遍历散列表)、show()(打印出哈希表所存的元素)返回值为bool类型的函数search\insert\Delete。search函数（查询关键字为key的元素的位值）、insert函数(插入元素e到哈希表中)、Delete函数（删除关键字为key的元素）。本程序的main函数同样采用两种类型的数据来进行测试，int型和char型，主要测试元素的插入、删除和搜索。
C++实现哈希表
Ly的博客
05-28 3123
本文主要是对哈希表这种数据结构进行介绍。含义是根据存储的值和存储的位置建立映射关系从而快速检索查找存储的数据，哈希表是一种非常高效的数据结构。本文会用C++介绍哈希表的相关实现。
C++ hash table 的编程实现
a130737的专栏
08-21 8944
关于Hash Table， 总结如下：
C++代码中使用哈希表
树欲静静风不止止的博客
08-30 4256
C++代码中如何使用哈希表
『数据结构』哈希表
叄拾叄画生
08-05 7141
什么是哈希？哈希冲突。哈希函数。哈希冲突解决方法。闭散列（线性探测、二次探测）。开散列（哈希桶）、开散列模拟实现（C++和Java）。
C++哈希表实现
Code is to be happy
12-18 1006
#include #include #include #define HASHLENGTH 10 struct node { int data; struct node *next; }; struct node hash[HASHLENGTH]; typedef struct node * HashNode; int Hash(int k) { return k%HASHLENGTH
c++实现哈希表
06-10
### C++ 实现哈希表的方法及代码示例 在 C++ 中，可以通过多种方式实现哈希表。一种简单且直接的方式是使用标准库中的 `std::unordered_map`[^1]。以下是一个基于 `std::unordered_map` 的实现示例： ```cpp #include <iostream> #include <unordered_map> int main() { // 创建一个 unordered_map，用于存储学生的分数 std::unordered_map<std::string, int> scores; // 插入键值对 scores["Alice"] = 95; scores["Bob"] = 85; scores["Charlie"] = 90; // 访问和修改值 std::cout << "Bob's score: " << scores["Bob"] << std::endl; scores["Bob"] = 88; std::cout << "Updated Bob's score: " << scores["Bob"] << std::endl; // 检查键是否存在 if (scores.find("Alice") != scores.end()) { std::cout << "Alice's score exists" << std::endl; } // 遍历哈希表 for (const auto& pair : scores) { std::cout << pair.first << ": " << pair.second << std::endl; } return 0; } ``` 此外，也可以通过手动实现哈希表来更深入地理解其工作原理。以下是一个简单的手写哈希表实现[^2]，采用开放地址法解决冲突： ```cpp #include <iostream> #include <cstring> using namespace std; const int N = 200003; // 哈希表大小，通常是数据量的2~3倍 const int null = 0x3f3f3f3f; // 表示空位置 int h[N]; // 哈希表 // 初始化哈希表 void init() { memset(h, 0x3f, sizeof h); } // 查找函数，同时用于插入和查找 int find(int x) { int t = (x % N + N) % N; // 计算哈希值 while (h[t] != null && h[t] != x) { // 如果当前位置已占用且不等于目标值 t++; // 线性探测 if (t == N) t = 0; // 如果遍历到末尾，则回到开头 } return t; // 返回目标值的位置或可插入位置 } int main() { init(); // 初始化哈希表 // 插入元素 int x = 10; int idx = find(x); if (h[idx] == null) { // 如果位置为空，则插入 h[idx] = x; cout << "Inserted " << x << " at index " << idx << endl; } else { cout << x << " already exists in the hash table" << endl; } // 查找元素 x = 10; idx = find(x); if (h[idx] != null) { cout << "Found " << x << " at index " << idx << endl; } else { cout << x << " not found in the hash table" << endl; } return 0; } ``` 以上两种方法分别展示了如何利用标准库和手动实现哈希表。前者更简洁高效，后者则有助于理解哈希表的底层机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值