散列表函数的实现

最新推荐文章于 2023-12-07 17:11:09 发布
最新推荐文章于 2023-12-07 17:11:09 发布
阅读量293 收藏
点赞数
分类专栏： 学生 
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;
//定义一个员工的类
class Employee{
    public:
        Employee(){name=""; salary=0.0; seniority=0;};// 初始构造函数
        Employee(const string & n, double sal, int sen):name(n), salary(sal), seniority(sen){}//赋值构造函数
        //获得该类的name成员
        const string & getName() const//返回一个string类型的引用
        { return name; }
 
        //重载==运算符   重载等号运算符  是为了下面查找键值的时候使用
        bool operator==(const Employee & rhs) const
        { return getName() == rhs.getName(); }
 
        //重载!=运算符 
        bool operator!=(const Employee & rhs) const
        { return !(*this == rhs); }
 //设计一个友元函数  用于输出信息
        friend ostream & operator<<(const ostream & os, const Employee & e){
            cout << "name: " << e.name << ",\tsalary: " << e.salary << ",\tseniority: " << e.seniority;
        }
    private:
        string name;//姓名
        double salary;//薪水
        int seniority;//级别
};
 
/****************************************************************
*   函数名称：hash(const HashedObj & key)
*   功能描述: 根据键值求个hash值,这个函数是根据一个特定的数学公式 
*   参数列表: key 数据项的键值 
*   返回结果：返回一个通过散列函数求得的值
*****************************************************************/
int hash(const string & key)
{
    int hashVal = 0;
 
    //用散列函数的那个公式求和
    for(int i = 0; i < key.length(); ++i)
        hashVal = 37*hashVal + key[i];
 
    return hashVal;//这是通过散列函数求得的值
}
 
/****************************************************************
*   函数名称：hash(const HashedObj & key)
*   功能描述: 根据Employee引用的键值求个hash值,这个函数是根据一个特定的数学公式 
*   参数列表: key 数据项的键值 
*   返回结果：返回一个通过散列函数求得的值
*****************************************************************/
int hash(const Employee & item)
{
    return hash(item.getName());
}
 
 
/****************************************************************
*   散列表类名称：HashTable
*   内容描述: 散列表类
*****************************************************************/
template<typename HashedObj>
class HashTable{
    public:
        explicit HashTable(int size = 11):array(nextPrime(size)), currentSize(0){makeEmpty();}//不能在隐式子转换中使用该函数
        ~HashTable();//析构函数
 
        bool containes(const HashedObj & x);//判断是否包含数据项x
        void makeEmpty();//清空散列表
        bool isEmpty();//判断是否是空表
        bool insert(const HashedObj & x);//插入项x
        bool remove(const HashedObj & x);//删除项x
 
        void print();//输出散列表中的内容
        int findPos(const HashedObj & x);//根据名字查找数据项
        HashedObj findElement(const HashedObj & x);//根据名字查找数据项,并返回
 //表明位置的状态信息
        enum EntryType {ACTIVE, EMPTY, DELETED};//每个数据单元都有一个info变量，表明该位置是否被占用、空或已删除
        
    private:
        //散列表的数据单元结构
        struct HashEntry{
            HashedObj element;//该散列表存放的数据
            EntryType info;//表明该位置的状态 对应与82行
            //结构的构造函数
            HashEntry(const HashedObj & e = HashedObj(), EntryType i = EMPTY):element(e), info(i){}
        };
 
        vector<HashEntry> array;//散列表  这是一个array数组
        int currentSize;//散列表中当前存放的元素个数
    private:
        void rehash();//再散列
        int myhash(const HashedObj & x) const;//散列函数
        int nextPrime(int n);//求的距离N最近的一个大于N的素数
        int prePrime(int n);//求距离N最近的一个小于N的素数
        bool isActive(int currentPos) const;//判断位置currentPos处的是否有元素
 
    public:
	//输出函数  输出这个点的信息
        friend ostream & operator<<(const ostream & os, const HashEntry & e){
            cout << "element: " << e.element << ", info = " << e.info;
        }
};
 
 
/****************************************************************
*   函数名称：findElement(const HashedObj & x) const
*   功能描述: 查找x的位置
*   参数列表: x是要查找的元素
*   返回结果：如果找到则返回该元素的引用
*****************************************************************/
template<typename HashedObj>
HashedObj HashTable<HashedObj>::findElement(const HashedObj & x)
{
    int currentPos = findPos(x);//找到x插入的位置
 
    if(isActive(currentPos))//找了则返回  isActive()函数判断这个位置的状态 也就是判断这个位置是否有元素
        return array[currentPos].element;//返回array数组这个位置的元素值
    else{//没有找到,返回一个空值
        HashedObj obj;
        return obj;
    }
}
 
 
/****************************************************************
*   函数名称：findPos(const HashedObj & x) const
*   功能描述: 查找x应该插入的位置
*   参数列表: x是要插入的元素
*   返回结果：如果找到空的位置则返回要插入的位置标号
*****************************************************************/
template<typename HashedObj>
int HashTable<HashedObj>::findPos(const HashedObj & x)
{
    //线性探测f(i) = i; f(i) = f(i-1) + 1;相隔为1
    //平方探测f(i) = i*i; f(i) = f(i-1) + 2*i - 1; 相隔为2*i-1
    //双散列，f(i) = i*hash2(x); f(i) = f(i-1)+hash2(x);相隔为hash2(x);
    //hash2(x) = R-(x%R); R=prePrime(array.size()),R为小于TableSize()的素数
    int offset = 1;
 
    int currentPos = myhash(x);
 
    //如果找到了空的位置则返回位置标号
    //如果找到了该元素x，则返回该元素的位置标号   找到这个位置前提的有元素  还要判断是否是要查找的元素
    while(array[currentPos].info != EMPTY && array[currentPos].element != x){
         //currentPos += offset;//线性探测
         currentPos += 2 * offset -1;//平方探测
         //currentPos += prePrime(array.size()) - myhash(x)%prePrime(array.size());//双散列
         offset++;
 
        if(currentPos >= array.size())
            currentPos -= array.size();
    }
    
    return currentPos;  //返回这个位置
}
 
 
/****************************************************************
*   函数名称：print()
*   功能描述: 输出散列表中的内容
*   参数列表: 无 
*   返回结果：无
*****************************************************************/
template<typename HashedObj>
void HashTable<HashedObj>::print()
{
	//<<已经被重载过了
    cout << "输出散列表中的内容: " << endl;
    for(unsigned i = 0; i < array.size(); ++i){
        if(isActive(i))//如果这个位置有元素 就输出
            cout << i << ": " << endl << array[i] << endl;
    }
}
 
/****************************************************************
*   函数名称：isEmpty()
*   功能描述: 判断散列表是否为空
*   参数列表: 无 
*   返回结果：无
*****************************************************************/
template<typename HashedObj>
bool HashTable<HashedObj>::isEmpty()
{
    return currentSize == 0;//是判断当前散列表的个数 根据散列表中元素的个数来判断这个表是否是空表
}
 
/****************************************************************
*   函数名称：makeEmpty()
*   功能描述: 清空散列表 
*   参数列表: 无 
*   返回结果：无
*****************************************************************/
template<typename HashedObj>
void HashTable<HashedObj>::makeEmpty()
{
    for(int i = 0; i < array.size(); ++i)
        array[i].info = EMPTY;//把信息定义为空
 
    currentSize = 0;//当前元素个数设为0
}
 
/****************************************************************
*   函数名称：containes(const HashedObj & x) const
*   功能描述: 判断散列表是否包含值为x的元素 
*   参数列表: x数据项
*   返回结果：如果包括x则返回true,否则返回false
*****************************************************************/
template<typename HashedObj>
bool HashTable<HashedObj>::containes(const HashedObj & x)
{
    //findPos(x)返回的位置是ACTIVE的说明存在该元素x
    return isActive(findPos(x));//判断位置x是否有元素
}
 
/****************************************************************
*   函数名称：isActive(int currentPos) const
*   功能描述: 判断位置currentPos处的是否有元素 
*   参数列表: currentPos是散列表currentPos处的位置 
*   返回结果：如果currentPos处有元素则返回true,否则返回false
*****************************************************************/
template<typename HashedObj>
bool HashTable<HashedObj>::isActive(int currentPos) const
{
    return array[currentPos].info == ACTIVE;//也就是查看这个点的状态  也就是比对状态信息是否是active
}
 
/****************************************************************
*   函数名称：remove(const HashedObj & x)
*   功能描述: 删除散列表中的值为x的元素 
*   参数列表: x数据项
*   返回结果：成功删除返回true,否则返回false
*****************************************************************/
template<typename HashedObj>
bool HashTable<HashedObj>::remove(const HashedObj & x)
{
    int currentPos = findPos(x);//查找x的位置 如果这点不存在  直接返回false
    if(!isActive(currentPos))
        return false;
 
    array[currentPos].info = DELETED;//懒惰删除，仅仅将标识位info设置为Deleted
 
    --currentSize;//元素个数减去1
    return true;
}
 
/****************************************************************
*   函数名称：insert(const HashedObj & x)
*   功能描述: 在散列表中插入元素x,如果插入项已经存在，则什么都不做。
*             否则将其放在表的前端
*   参数列表: x数据项
*   返回结果：插入成功返回true, 否则返回false
*****************************************************************/
template<typename HashedObj>
bool HashTable<HashedObj>::insert(const HashedObj & x)
{
    int currentPos = findPos(x);//先找到位置
    if(isActive(currentPos))//如果该位置处已经存放了该元素，就是这里有与插入的值相等的元素,则之间返回false
        return false;
 
    array[currentPos] = HashEntry(x, ACTIVE);//把这个数据单元放到散列表中去
 
    //如果当前散列表中元素的个数大于散列表长度的一半，则扩大散列表为原来的2倍
//散列表扩容
    if(++currentSize > array.size()/2)
        rehash();//扩充表的大小
 
    return true;
 
}
 
 
/****************************************************************
*   函数名称：~HashTable()
*   功能描述: 析构函数
*   参数列表: 无
*   返回结果：无
*****************************************************************/
template<typename HashedObj>
HashTable<HashedObj>::~HashTable()
{
    
}
 
 
/****************************************************************
*   函数名称：prePrime(int n)
*   功能描述: 获得距离n最近的一个小于n的素数 
*   参数列表: n表示数值 
*   返回结果：返回一个素数 
*****************************************************************/
template<typename HashedObj>
int HashTable<HashedObj>::prePrime(int n)
{
    int i;
 
    if(n % 2 == 0)
        n--;
 
    for(; ; n -= 2){
        for(i = 3; i*i <= n; i += 2){//i是从3开始 对其取余数 然后判断是否是素数 如果是则返回
            if(n % i == 0)
                goto ContOuter;//这个的作用就是跳出这个循环
        }
        return n;
 
        ContOuter: ;
    }
}
 
/****************************************************************
*   函数名称：nextPrime(int n)
*   功能描述: 获得距离n最近的一个大于n的素数 
*   参数列表: n表示数值 
*   返回结果：返回一个素数 
*****************************************************************/
template<typename HashedObj>
int HashTable<HashedObj>::nextPrime(int n)
{
    int i;
 
    if(n % 2 == 0)//要求得是素数 首先排除偶数这一选项
        n++;
 
    for(; ; n += 2){
        for(i = 3; i*i <= n; i += 2)
            if(n % i == 0)
                goto ContOuter;
        return n;
        ContOuter: ;
    }
}
/****************************************************************
*   函数名称：rehash()
*   功能描述: 扩大散列表的大小
*   参数列表: 无
*   返回结果：无 
*****************************************************************/
template<typename HashedObj>
void HashTable<HashedObj>::rehash()
{
    
    vector<HashEntry> oldArray = array;
 
    //创建一个新的大小为原来两倍大小的散列表
    array.resize(nextPrime(2 * oldArray.size()));
 //先将其初始化为空
    for(int i = 0; i < array.size(); ++i)
        array[i].info = EMPTY;
 
    currentSize = 0;
    //复制散列表  将原来散列表的信息复制过来
    for(int i = 0; i < oldArray.size(); ++i){
        if(oldArray[i].info == ACTIVE)
            insert(oldArray[i].element);
    }
}
 
/****************************************************************
*   函数名称：myhash(const HashedObj & key)
*   功能描述: 根据键值求个hash值 
*   参数列表: key 数据项的键值 
*   返回结果：返回hash值
*****************************************************************/
template<typename HashedObj>
int HashTable<HashedObj>::myhash(const HashedObj & key) const
{
    int hashVal = hash(key);
    
    hashVal %= array.size();//根据键值获得哈希值   取余数的的除数设置为这个数组的长度
 
    if(hashVal < 0)
        hashVal += array.size();
 
    return hashVal;
}
 
 
 
 
int main()
{//先初始化这些数据
    Employee e1("linux", 101.00, 1);
    Employee e2("ever", 102.00, 2);
    Employee e3("peter", 103.00, 3);
    Employee e4("may", 104.00, 4);
    Employee e5("usa", 105.00, 5);
    Employee e6("sal", 106.00, 6);
    Employee e7("usa", 107.00, 7);//和上面的值重复，所以这个值会被忽略
    Employee e8("jan", 108.00, 8);
    Employee e9("kro", 109.00, 9);
    Employee e10("bei", 110.00, 10);
    
    Employee e12("bbb", 110.00, 10);
 //再讲这些值放入到数组中去
    vector<Employee> v;
    v.push_back(e1);
    v.push_back(e2);
    v.push_back(e3);
    v.push_back(e4);
    v.push_back(e5);
    v.push_back(e6);
    v.push_back(e7);
    v.push_back(e8);
    v.push_back(e9);
    v.push_back(e10);
 
    cout << "v: " << endl;
	//先输出这个哈希散列表的值
    for(unsigned i = 0; i < v.size(); ++i)
        cout << v[i] << endl;
    cout << endl;
 
    HashTable<Employee> hashTable;
    
    for(unsigned i = 0; i < v.size(); ++i)
       //那个散列表数组中的元素都插入到哈希表中去
	 hashTable.insert(v[i]);
 //输出哈希表的信息
    hashTable.print();
 
    cout << endl;
 
    cout << "测试包含函数containes: " << endl; 
    if(hashTable.containes(e10))
        cout << "containe e10" << endl;
    else 
        cout << "not containe e10" << endl;
 
    if(hashTable.containes(e12))
        cout << "containe e12" << endl;
    else 
        cout << "not containe e12" << endl;
        
    cout << "\n测试findElement(): " << endl;
    
    Employee e11 = hashTable.findElement(e8);
    cout << "e11: " << e11 << endl;
    cout << endl;
 
    cout << "测试isEmpty(): " << endl;
    if(hashTable.isEmpty())
        cout << "hashTable is Empty " << endl;
    else
        cout << "hashTable is not Empty " << endl;
    cout << endl;
 
    cout << "测试makeEmpty(): " << endl;
    hashTable.makeEmpty();
    if(hashTable.isEmpty())
        cout << "hashTable is Empty " << endl << endl;
    else
        cout << "hashTable is not Empty " << endl;
 
    return 0;
}

下面是运行的结果

v: 
name: linux,	salary: 101,	seniority: 1
name: ever,	salary: 102,	seniority: 2
name: peter,	salary: 103,	seniority: 3
name: may,	salary: 104,	seniority: 4
name: usa,	salary: 105,	seniority: 5
name: sal,	salary: 106,	seniority: 6
name: usa,	salary: 107,	seniority: 7
name: jan,	salary: 108,	seniority: 8
name: kro,	salary: 109,	seniority: 9
name: bei,	salary: 110,	seniority: 10

输出散列表中的内容: 
1: 
element: name: kro,	salary: 109,	seniority: 9, info = 0
3: 
element: name: jan,	salary: 108,	seniority: 8, info = 0
4: 
element: name: may,	salary: 104,	seniority: 4, info = 0
5: 
element: name: bei,	salary: 110,	seniority: 10, info = 0
6: 
element: name: usa,	salary: 105,	seniority: 5, info = 0
17: 
element: name: ever,	salary: 102,	seniority: 2, info = 0
18: 
element: name: sal,	salary: 106,	seniority: 6, info = 0
21: 
element: name: peter,	salary: 103,	seniority: 3, info = 0
22: 
element: name: linux,	salary: 101,	seniority: 1, info = 0

测试包含函数containes: 
containe e10
not containe e12

测试findElement(): 
e11: name: jan,	salary: 108,	seniority: 8

测试isEmpty(): 
hashTable is not Empty 

测试makeEmpty(): 
hashTable is Empty

添加链接描述

奥斯特洛夫斯勇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
散列表性质与实现
飞扬的青春的专栏
08-26 1147
原文转自：  http://blog.csdn.net/intrepyd/article/details/4359818
散列表--散列函数
iEucliwood的博客
01-01 540
一般想法 理想的散列表数据结构只不过是一个含有关键字的具有固定大小的数组。典型情况下，一个关键字就是一个带有相关值（例如工资信息）的字符串。我们把表的大小记作 tableSize，并将其理解为散列数据结构的一部分，而不仅仅是浮动于全局的某个遍历。通常的习惯是让表从0到tableSize-1变化。 将每个关键字映射到从0到tableSize-1这个范围中的某个数，并且放到适当的单元中。这个映射叫作散列函数（hash function），理想情况下它应该运算简单并且应该保证任何两个不同的关键...
JS实现散列函数（代码+测试）
weixin_46726346的博客
12-14 396
代码 <script> //创建散列函数类 function HashTable() { this.table = new Array(137); } //用霍纳算法计算哈希值 HashTable.prototype.betterHash = function (string) { const H = 37; var totle = 0;
散列表
songsongL的博客
08-11 1250
文章目录散列表概念散列表主要两个问题散列函数的构造处理冲突的方法散列表的查找完整代码：运行结果： 散列表概念 散列函数和散列地址：类似于函数y=f(x),给定一个x，能得到一个y。散列函数，给定一个关键字，可以得到一个地址。但有时不同的key可能得到相同的p，需要 处理冲突。 p=Hey(key)。 散列表：一个有限连续的地址空间，用以存储散列函数计算得到相应散列地址的数据记录。 散列表...
一个简单的散列（hashing）函数
张三金的博客
08-05 1016
以前没写过，写一个简单的试试！ 散列的定义：散列是一种用于以常数平均时间执行插入、删除和查找的技术； 散列函数：每个关键字被映射到0到TableSize - 1 的这个范围中的某个数，并且被放到适当的单元中，这个映射就叫做散列函数 一个简单的散列函数 /** * * @param key 关键字 * @param tableSize 表格的大小 **/ public st...
课程设计 散列表 的设计与实现.
03-11
散列表的设计与实现,课程设计. 设计散列表实现电话号码查找系统。 【基本要求】 1) 设每个记录有下列数据项：电话号码、用户名、地址； 2) 从键盘输入各记录，分别以电话号码和用户名为关键字建立散列表； 3) 采用...
散列表的设计与实现_散列表的设计与实现_
10-03
设计散列表实现电话号码查找系统。基本要求：(1)设每个记录有下列数据项：电话号码、用户名、地址；(2)从键盘输入各记录，分别以电话号码和用户名为关键字建立散列表；(3)采用双散列法解决冲突；(4)查找并显示给定...
sanliebiao.rar_sanliebiao_散列表_散列表c++实现
09-24
散列表通过散列函数将关键字映射到数组的索引位置，从而实现了快速的插入、删除和查找操作。在C++中实现散列表，我们可以充分利用C++的特性来提高效率和代码的可读性。 首先，散列表的基本思想是利用哈希函数（Hash...
散列表实现
07-04
数据结构课程中的散列表的编程实现，c语言
散列表的原理与Java实现方法详解
08-25
总的来说，散列表是通过巧妙地使用散列函数和链表来实现的高效数据结构，它在时间和空间之间寻找平衡，提供快速的键值对操作。理解其工作原理和Java中的实现细节对于优化程序性能至关重要。在实际开发中，应根据数据...
【数据结构】散列表
程序员小潘
06-29 353
【需求】 设计一个容器，支持add操作，但是不允许添加重复的元素，如果元素重复则覆盖。支持contains操作，快速判断元素是否已存在。 大家看到这个需求的时候，脑子里第一个想到的实现思路是什么？ ​ 最简单的做法就是创建一个数组来存储元素，每次add时遍历一下数组，判断是否已存在。这么做确实可以实现需求，但是效率太低了，每次操作的时间复杂度都是O(n)。看我们如何用「散列表」这种数据结构来优化它。 ​ 1. 散列表概述 散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直
数据结构与算法——散列表类的C++实现(探测散列表)
Be The Best！
04-13 7487
散列表类的C++实现(探测散列表)...
数据结构-散列表
08-15 248
一、散列函数 散列表是表示集合和字典的另一种有效方法，通过将关键码映射到表中某个位置来存储元素，然后根据关键码用同样的方法直接访问。 散列方法使用的转换函数即散列函数，散列函数不能太复杂。 散列函数定义域必须包括全部关键码，值域必须在0到m-1之间（m为散列表允许的地址数），通常关键码集合比散列地址集合大得多，因此散列函数是一种压缩映像函数。对不同关键码，通过散列函数的计算可能得到...
【Java集合 2】Java链表、散列表、HashSet、TreeSet
学Java，找哪吒
04-04 2923
从数组中间删除一个元素开销很大，其原因是向数组中插入元素时，此元素之后的所有元素都要向后端移动，删除时也是，数组中位于被删除元素之后的所有元素都要向数组的前端移动。
边学边记——数据结构☞和搜索有关的数据结构（搜索树，Set，Map，哈希表）
lil_ghost_的博客
05-05 839
虽然哈希表一直在和冲突做斗争，但在实际使用过程中，我们认为哈希表的冲突率是不高的，冲突个数是可控的，也就是每个桶中的链表的长度是一个常数，所以，通常意义下，我们认为哈希表的插入/删除/查找时间复杂度是O(1)。比如在之前的场景，现在需要插入元素44，先通过哈希函数计算哈希地址，下标为4，因此44理论上应该插在该位置，但是该位置已经放了值为4的元素，即发生哈希冲突。对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
哈希表的使用
热门推荐
denny的专栏
03-12 2万+
数据结构：hash_map原理 这是一节让你深入理解hash_map的介绍，如果你只是想囫囵吞枣，不想理解其原理，你倒是可以略过这一节，但我还是建议你看看，多了解一些没有坏处。hash_map基于hash table（哈希表）。哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存。然而在当前可利用内存越来越多的情况下，用空间换时间的做
深入探讨403错误产生的根本原因，并提供几种解决403错误方法
最新发布
s__777的博客
12-07 6万+
在互联网的日常使用过程中，我们可能会遇到一些难以理解的错误代码，其中之一就是403错误。这个错误通常表现为"403 Forbidden"或"HTTP Status 403"，它指的是访问资源被服务器理解但拒绝授权。换句话说，服务器可以理解你请求看到的页面，但它拒绝给你权限。今天就和大家深入探讨403错误产生的根本原因，并提供几种解决403错误方法。
Http状态码
lonzgzhouzhou的博客
09-13 1625
被用于当资源的访问由于法律原因被禁止的时候。497：（HTTP到HTTPS（Nginx））Nginx内置的代码，被用于原始的HTTP的请求发送给HTTPS端口去分辨4XX在日志中和一个错误页面的重定向。598：（网络读取超时异常(未知)）这个状态码也没有在任何RFC中指定，但是被用在微软的HTTP代理中去标注一个网络读取超时在一个客户端之前的代理的后面。599：（网络连接超时异常(未知)）这个状态码也没有在任何RFC中指定，但是被用在微软的HTTP代理中去标注一个网络连接超时在一个客户端之前的代理的后面。
散列表：从理论到实践的艺术与科学
在计算机科学中，散列表是一种常用的数据结构，它通过哈希函数将键（Key）映射到数组的索引位置，从而实现快速的查找、插入和删除操作。散列表的核心在于哈希函数的设计，一个好的哈希函数能够尽可能地将不同的键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值