【数据结构】简单哈希表的实现（开散列）

最新推荐文章于 2024-08-04 21:48:35 发布
最新推荐文章于 2024-08-04 21:48:35 发布
阅读量714 收藏 2
点赞数
分类专栏： 【数据结构】C语言版 文章标签： 数据结构 哈希表 hashtable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qregi/article/details/79432075
版权

数据结构之哈希表的实现（开散列）


开散列的方法是，在哈希表中，把数组的每个元素都设置成一个单链表的头节点指针，也可以是不带头节点的单链表


如果出现哈希冲突，就把元素插入那个元素位置的单链表


哈希表结构体的代码如下：

#define HASHMAXSIZE 1000

typedef int HashType;
typedef int ValueType;

typedef size_t(*HashFunc)(HashType);

typedef struct HashElem{
	HashType key;
	ValueType value;
	struct HashElem* _next;
}HashElem;

typedef struct HashTable{
	HashElem* data[HASHMAXSIZE];
	size_t size;
	HashFunc hash_func;
}HashTable;

哈希表的初始化：


把ｓｉｚｅ设置为０，把哈希函数初始化，再把数组里面的每个元素都设置为ＮＵＬＬ指针

代码如下：

/*初始化*/
void HashTableInit(HashTable* ht, HashFunc hash_func) {
	if (ht == NULL) {
		return;
	}
	int i = 0;
	for (; i < HASHMAXSIZE; i++) {
		ht->data[i] = NULL;
	}
	ht->size = 0;
	ht->hash_func = hash_func;
}


哈希表的插入：

方法是，找到要插入的数组下标，判断该元素是否存在，如果存在（不包含元素相同的值），

　　就插入失败，否则，就是往单链表里插入一个元素（建议头插，比较方便）

代码如下：

HashElem* HashTableBucketFind(HashElem* head, HashType key) {
	if (head == NULL) {
		return NULL;
	}
	HashElem* cur = head;
	while (cur) {
		if (cur->key == key) {
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

HashElem* CreateNewNode(HashType key, ValueType value) {
		
	HashElem* new_node = (HashElem*)malloc(sizeof(HashElem));
	if (new_node != NULL) {
		new_node->key = key;
		new_node->value = value;
		new_node->_next = NULL;
	}
	return new_node;
}

/*插入*/
int HashTableInsert(HashTable* ht, HashType key, ValueType value) {
	if (ht == NULL) {
		return;
	}
	size_t offset = ht->hash_func(key);
	/*
	**找到该元素的存放位置
	**遍历链表，判断有没有相同的元素
	**如果没有，就头插然后返回1， 如果有，就退出，返回0
	*/
	HashElem* cur = HashTableBucketFind(ht->data[offset], key);
	if (cur == NULL) {
		/*表示可以直接插入*/
		HashElem* to_insert = CreateNewNode(key, value);
		to_insert->_next = ht->data[offset];
		ht->data[offset] = to_insert;
		++ht->size;
	}
	else {
		/*表示在当前位置有相同的元素，则不能插入*/
		return 0;
	}
}

哈希表的查找：


这个比较叫简单，用的函数还是上面插入时候查找函数

代码如下：

/*查找*/
int HashTableFind(HashTable* ht, HashType key, ValueType* value) {
	if (ht == NULL || value == NULL) {
		return 0;
	}
	size_t offset = ht->hash_func(key);
	HashElem* cur = HashTableBucketFind(ht->data[offset], key);
	if (cur == NULL) {
		/*没找到*/
		return 0;
	}
	else {
		*value = cur->value;
		return 1;
	}
}

哈希表的删除：


删除是，找到该元素，然后删除单链表上的一个节点，这里用的主要是单链表那块的知识，也比较简单

代码如下：

int HashBucketCur_Pre(HashElem* head, HashElem** cur, HashElem** pre, HashType key) {
	if (head == NULL) {
		return 0;
	}
	if (cur == NULL || pre == NULL) {
		return 0;
	}
	*cur = head;
	while (*cur) {
		if ((*cur)->key == key) {
			return 1;
		}
		*pre = *cur;
		*cur = (*cur)->_next;
	}
	return 0;
}

void DestoryHashElem(HashElem* node) {
	if (node == NULL) {
		return;
	}
	free(node);
}

/*删除*/
int HashTableRemove(HashTable* ht, HashType key) {
	if (ht == NULL) {
		return;
	}
	size_t offset = ht->hash_func(key);
	HashElem* pre = NULL;
	HashElem*  cur = NULL;
	int ret = HashBucketCur_Pre(ht->data[offset], &cur, &pre, key);
	if (ret == 0) {
		/*没有找到*/
		printf("该元素不在哈希表中!\n");
		return 0;
	}
	else {
		/*找到了*/
		if (cur == ht->data[offset]) {
			/*要删除的是头节点*/
			ht->data[offset] = cur->_next;
			DestoryHashElem(cur);
			cur = NULL;
			--ht->size;
			return 1;
		}
		else {
			pre->_next = cur->_next;
			DestoryHashElem(cur);
			cur = NULL;
			--ht->size;
			return 1;
		}// cur != ht->data[offset]
	}//ret != 0
}//函数结束


剩下的几个都是简单的操作，全部代码在下面


我这里实现的是一个简单的哈希表，哈希表这块还需要认真学习，需要拓展一下，比如，如何存储字符串之类的问题


全部代码如下：


HashTable.h

#pragma once

#include<stdio.h>
#include<stddef.h>

#define HASHMAXSIZE 1000

typedef int HashType;
typedef int ValueType;

typedef size_t(*HashFunc)(HashType);

typedef struct HashElem{
	HashType key;
	ValueType value;
	struct HashElem* _next;
}HashElem;

typedef struct HashTable{
	HashElem* data[HASHMAXSIZE];
	size_t size;
	HashFunc hash_func;
}HashTable;

/*初始化*/
void HashTableInit(HashTable* ht, HashFunc hash_func);

/*插入*/
int HashTableInsert(HashTable* ht, HashType key, ValueType value);

/*查找*/
int HashTableFind(HashTable* ht, HashType key, ValueType* value);

/*删除*/
int HashTableRemove(HashTable* ht, HashType key);

/*哈希表中的数据数量*/
size_t HashTableSize(HashTable* ht);

/*哈希表判空*/
int HashTableEmpty(HashTable* ht);

/*销毁哈希表*/
void HashTableDestory(HashTable* ht);

HashTable.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"HashTable(open).h"
#include<stdio.h>
#include<stdlib.h>

/*初始化*/
void HashTableInit(HashTable* ht, HashFunc hash_func) {
	if (ht == NULL) {
		return;
	}
	int i = 0;
	for (; i < HASHMAXSIZE; i++) {
		ht->data[i] = NULL;
	}
	ht->size = 0;
	ht->hash_func = hash_func;
}

HashElem* HashTableBucketFind(HashElem* head, HashType key) {
	if (head == NULL) {
		return NULL;
	}
	HashElem* cur = head;
	while (cur) {
		if (cur->key == key) {
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}

HashElem* CreateNewNode(HashType key, ValueType value) {
		
	HashElem* new_node = (HashElem*)malloc(sizeof(HashElem));
	if (new_node != NULL) {
		new_node->key = key;
		new_node->value = value;
		new_node->_next = NULL;
	}
	return new_node;
}

/*插入*/
int HashTableInsert(HashTable* ht, HashType key, ValueType value) {
	if (ht == NULL) {
		return;
	}
	size_t offset = ht->hash_func(key);
	/*
	**找到该元素的存放位置
	**遍历链表，判断有没有相同的元素
	**如果没有，就头插然后返回1， 如果有，就退出，返回0
	*/
	HashElem* cur = HashTableBucketFind(ht->data[offset], key);
	if (cur == NULL) {
		/*表示可以直接插入*/
		HashElem* to_insert = CreateNewNode(key, value);
		to_insert->_next = ht->data[offset];
		ht->data[offset] = to_insert;
		++ht->size;
	}
	else {
		/*表示在当前位置有相同的元素，则不能插入*/
		return 0;
	}
}

/*查找*/
int HashTableFind(HashTable* ht, HashType key, ValueType* value) {
	if (ht == NULL || value == NULL) {
		return 0;
	}
	size_t offset = ht->hash_func(key);
	HashElem* cur = HashTableBucketFind(ht->data[offset], key);
	if (cur == NULL) {
		/*没找到*/
		return 0;
	}
	else {
		*value = cur->value;
		return 1;
	}
}

int HashBucketCur_Pre(HashElem* head, HashElem** cur, HashElem** pre, HashType key) {
	if (head == NULL) {
		return 0;
	}
	if (cur == NULL || pre == NULL) {
		return 0;
	}
	*cur = head;
	while (*cur) {
		if ((*cur)->key == key) {
			return 1;
		}
		*pre = *cur;
		*cur = (*cur)->_next;
	}
	return 0;
}

void DestoryHashElem(HashElem* node) {
	if (node == NULL) {
		return;
	}
	free(node);
}

/*删除*/
int HashTableRemove(HashTable* ht, HashType key) {
	if (ht == NULL) {
		return;
	}
	size_t offset = ht->hash_func(key);
	HashElem* pre = NULL;
	HashElem*  cur = NULL;
	int ret = HashBucketCur_Pre(ht->data[offset], &cur, &pre, key);
	if (ret == 0) {
		/*没有找到*/
		printf("该元素不在哈希表中!\n");
		return 0;
	}
	else {
		/*找到了*/
		if (cur == ht->data[offset]) {
			/*要删除的是头节点*/
			ht->data[offset] = cur->_next;
			DestoryHashElem(cur);
			cur = NULL;
			--ht->size;
			return 1;
		}
		else {
			pre->_next = cur->_next;
			DestoryHashElem(cur);
			cur = NULL;
			--ht->size;
			return 1;
		}// cur != ht->data[offset]
	}//ret != 0
}//函数结束


/*哈希表中的数据数量*/
size_t HashTableSize(HashTable* ht) {
	if (ht == NULL) {
		return 0;
	}
	return ht->size;
}

/*哈希表判空*/
int HashTableEmpty(HashTable* ht) {
	if (ht == NULL) {
		return 1;
	}
	int i = 0;
	for (; i < HASHMAXSIZE; i++) {
		if (ht->data[i] != NULL) {
			return 0;
		}
	}
	return 1;
}

/*销毁哈希表*/
void HashTableDestory(HashTable* ht) {
	if (ht == NULL) {
		return;
	}
	int i = 0;
	for (; i < HASHMAXSIZE; ++i) {
		if (ht->data[i] != NULL) {
			/*表示该位置有元素，遍历然后删除*/
			HashElem* cur = ht->data[i];
			HashElem* to_delte = NULL;
			while (cur) {
				to_delte = cur;
				cur = cur->_next;
				DestoryHashElem(to_delte);
				to_delte = NULL;

				ht->data[i] = NULL;
			}//cur == NULL
		}//ht->data[i] == NULL
	}//i >= HASHMAXSIZE
	ht->size = 0;
	ht->hash_func = NULL;
}


test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"HashTable(open).h"
#include<stdio.h>
#include<stdlib.h>

size_t hash_func(HashType key) {
	return key % HASHMAXSIZE;
}

#define TESTHEAD printf("------------%s------------\n",__FUNCTION__)

void HashTablePrint(HashTable* ht) {
	if (ht == NULL) {
		return;
	}
	int i = 0;
	for (; i < HASHMAXSIZE; ++i) {
		if (ht->data[i] != NULL) {
			HashElem* cur = ht->data[i];
			while (cur) {
				printf("[%d]: key = %4d, value = %5d, _next->   ", i, cur->key, cur->value);
				cur = cur->_next;
			}
			printf("NULL\n");
		}
	}
}

void TestInit() {
	HashTable ht;
	TESTHEAD;
	HashTableInit(&ht, hash_func);
	int i = 0;
	for (; i < HASHMAXSIZE; ++i) {
		if (ht.data[i] != NULL) {
			printf("index = %d 的位置未被初始化\n", i);
		}
	}
	printf("expect 0, actual:%d\n", ht.size);
	printf("expect %p, actual:%p\n", hash_func, ht.hash_func);
}

void TestInsert() {
	HashTable ht;
	TESTHEAD;
	HashTableInit(&ht, hash_func);
	HashTableInsert(&ht, 101, 100);
	HashTableInsert(&ht, 102, 200);
	HashTableInsert(&ht, 1001, 300);
	HashTableInsert(&ht, 1001, 400);
	HashTableInsert(&ht, 1002, 500);
	HashTableInsert(&ht, 1, 100);
	HashTableInsert(&ht, 2, 200);
	HashTablePrint(&ht);
}

void TestFind() {
	HashTable ht;
	TESTHEAD;
	HashTableInit(&ht, hash_func);
	HashTableInsert(&ht, 101, 100);
	HashTableInsert(&ht, 102, 200);
	HashTableInsert(&ht, 1001, 300);
	HashTableInsert(&ht, 1001, 400);
	HashTableInsert(&ht, 1002, 500);
	HashTableInsert(&ht, 1, 600);
	HashTableInsert(&ht, 2, 700);
	HashTablePrint(&ht);

	ValueType value = -1;
	int ret = HashTableFind(&ht, 101, &value);
	printf("expect 1, actual:%d\n", ret);
	printf("expect 100, actual:%d\n", value);
	int ret2 = HashTableFind(&ht, 103, &value);
	printf("expect 0, actual:%d\n", ret2);

	int ret3 = HashTableFind(&ht, 1002, &value);
	printf("expect 1, actual:%d\n", ret3);
	printf("expect 500, actual:%d\n", value);
}

void TestRemove() {
	HashTable ht;
	TESTHEAD;
	HashTableInit(&ht, hash_func);
	HashTableInsert(&ht, 1001, 300);
	HashTableInsert(&ht, 1001, 400);
	HashTableInsert(&ht, 1002, 500);
	HashTableInsert(&ht, 1, 600);
	HashTableInsert(&ht, 2, 700);
	printf("删除前：\n");
	HashTablePrint(&ht);

	/*测试删除一个头节点元素*/
	printf("删除后:\n");
	HashTableRemove(&ht, 1);
	HashTablePrint(&ht);
	/*测试删除不存在的元素*/
	printf("测试删除哈希表中不存在的元素:\n");
	HashTableRemove(&ht, 1);
	HashTablePrint(&ht);

	/*测试删除正常元素*/
	printf("测试删除正常元素:\n");
	HashTableRemove(&ht, 1001);
	HashTableRemove(&ht, 1002);

	HashTablePrint(&ht);

}

void TestHash_Size_Empty() {
	HashTable ht;
	TESTHEAD;
	HashTableInit(&ht, hash_func);
	int ret = HashTableEmpty(&ht);
	printf("expect 1, actual:%d\n", ret);
	HashTableInsert(&ht, 1001, 300);
	HashTableInsert(&ht, 1001, 400);
	HashTableInsert(&ht, 1002, 500);
	HashTableInsert(&ht, 1, 600);
	HashTableInsert(&ht, 2, 700);
	printf("删除前：\n");
	HashTablePrint(&ht);
	ret = HashTableEmpty(&ht);
	printf("expect 0, actual:%d\n", ret);
	size_t sz = HashTableSize(&ht);
	printf("expect 4, actual:%d\n", sz);
}

void TestDestory() {
	HashTable ht;
	TESTHEAD;
	HashTableInit(&ht, hash_func);

	HashTableInsert(&ht, 1001, 100);
	HashTableInsert(&ht, 1001, 200);
	HashTableInsert(&ht, 1002, 300);
	HashTableInsert(&ht, 1, 400);
	HashTableInsert(&ht, 2, 500);
	HashTableInsert(&ht, 3, 600);
	HashTableInsert(&ht, 4, 700);
	HashTableInsert(&ht, 5, 800);
	HashTableInsert(&ht, 6, 900);
	HashTableInsert(&ht, 7, 1000);
	HashTablePrint(&ht);

	HashTableDestory(&ht);
}

int main() {
	TestInit();
	TestInsert();
	TestFind();
	TestRemove();
	TestHash_Size_Empty();
	TestDestory();
	system("pause");
	return 0;
}



Qregi
关注
专栏目录
哈希表---------开散列实现
落叶知秋深的博客
05-23 196
HashTable.h: #include&lt;stddef.h&gt; #define HashMaxSize 1000 typedef int KeyType; typedef int ValueType; typedef size_t(*HashFunc)(KeyType key); typedef struct HashElem{ KeyType key; ...
数据结构——哈希表（散列）原理与代码应用
流楚丶格念的博客
10-24 5351
文章目录什么是哈希表？Hash的应用Hash复杂度散列表的查找步骤散列函数（哈希函数）——散列地址哈希表优缺点优点：缺点：散列的三种方法1、除法散列法2、平方散列法3、斐波那契（Fibonacci）散列法散列冲突的解决方案：扩展代码应用 什么是哈希表？ 哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 记录的存储位置=f(关键
一些经典简单的哈希函数
12-21
平时收集的一些哈希函数，用于多种不同的环境
sicily 4699. 简单哈希
aa662665的博客
11-19 165
Description 使用线性探测法(LinearProbing)可以解决哈希中的冲突问题，其基本思想是：设哈希函数为h(key)=d,并且假定哈希的存储结构是循环数组,则当冲突发生时,继续探测d+1,d+2…,直到冲突得到解决. 例如,现有关键码集为{47，7，29，11，16，92，22，8，3}， 设：哈希表表长为m=11；哈希函数为Hash(k...
数据结构 - 哈希表
最新发布
2302_79539362的博客
08-04 1217
数据结构 - 散列表
哈希表的简单实现例子
欧阳海宾
05-06 5657
Hash // Hash.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include &lt;iostream&gt; using namespace std; enum {COUNT=17}; typedef int DATA ; struct SNode { DATA d...
哈希表一个简单的实现
Make Progress Everyday!
03-29 891
hash table（哈希表) 哈希表最大的优点，就是把数据的存储和查找消耗的时间大大降低，几乎可以看成是常数时间；而代价仅仅是消耗比较多的内存。然而在当前可利用内存越来越多的情况下，用空间换时间的做法是值得的。另外，编码比较容易也是它的特点之一。其基本原理是：使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下
数据结构 C语言 哈希表.docx
03-28
### 数据结构：C语言实现哈希表 #### 核心知识点概述 本篇文章将围绕一个C语言中的哈希表实现案例展开，详细解析哈希表的基本概念、设计思路及其实现过程。通过阅读本文，您将了解到哈希表在C语言编程中的应用，并...
基于C语言实现哈希表（开散列）
L_X_Y_HH的博客
05-29 2712
上一篇博客写了基于线性探测实现哈希表的一些方法，但若是负载因子较大时，哈希表的查找数据效率还是会很低，下面将使用开散列来实现哈希表的一些操作开散列又称为链地址法（开链法）首先对关键码集合用散列函数计算散列地址，具有相同地址的关键码归于同一子集合，每一个集合称为一个桶，桶中的元素通过一个单链表链接起来，各链表的头结点存储在哈希表中例如：数据集合{10，51，14，33，18，29}，哈希函数Hash...
数据结构之哈希表
桐花思雨
05-22 1030
目录哈希表简述几种典型数据结构特点 哈希表简述 散列表的英文名称为 hash table，因此散列表又被称为哈希表，散列函数又被称为哈希函数 散列表通常基于数组来实现。借助散列函数对数组进行扩展，利用的是数组支持按照下标随机访问元素的特性 存放数据的时候，散列函数根据 f(key) 计算出数据应该存储的位置即数组下标，从而将不同的数据分散在不同的存储位置，这也是散列的由来 查找的时候，通过散列函数 f(key) 直接确定查找 hash 值所在位置即数组下标。而不需要一个个比较，直接找到数据，提升效率 散列
数据结构实验报告--姓名哈希表的设计与实现.doc
11-12
针对某集合中的“人名”设计并实现一个哈希表。 任务要求：针对姓名信息进行初始化哈希表，可以进行显示哈希表，查找元素。 设计思想：哈希函数用除留余数法构造，用线性探测再散列处理冲突。 设人名为中国人姓名...
哈希表的简单实现
DARK灬
11-09 129
方程的解 已知是中的整数，求出满足方程的解有多少组？数据范围如下：,、、、均小于， #include &lt;bits/stdc++.h&gt; using namespace std; typedef unsigned long long LL; const int MAXN=10000000; int f[MAXN*2]; int tmp,p,t,a,b,c,d,i,j; LL ans...
哈希表简单实现
huzk4409的专栏
12-10 230
#include &lt;string.h&gt; #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef struct _node{     char *name;     char *desc;     struct _node *next; }node; #define HASHSIZE 10 static node* has...
哈希表的一个简单实现
qq_43061349的博客
03-06 498
引子 先来看一个问题： SCP基金会建立了一个收容点，为每一个收容的SCP都编号为“SCP-xxxx-xx”。编号的每一个SCP都有一个专门的文件描述其收容注意事项。请你设计一个程序，输入编号就可以找到对应的文件并且输出。 这个问题的核心在于，如何通过编号迅速找到对应的文件。如果我们使用fstream对象来代表文件的话，一个可能的思路是这样的： struct SCP{ fstream document;//文件 string codeName;// 编号 }; int main(){
哈希表(散列)的实现
学习笔记
01-27 242
散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的id时,要求查找到该员工的 所有信息. 要求: 不使用数据库,尽量节省内存,速度越快越好=>哈希表(散列) package com.whb.hashtab; i
哈希表概念及简单实现
xd6905的博客
05-30 616
目录 1 什么是哈希表 2 哈希冲突 2.1 冲突解决 2.1.1 重新设计哈希函数 2.1.2 闭散列（开放地址法） 2.1.3 开散列（拉链法） 2.2 哈希表扩容 3 代码实现 3.1闭散列 3.1.1 查找 3.1.2 插入 3.1.3 删除 3.2 开散列 3.2.1 查找 3.2.2 插入 3.2.3 删除 1 什么是哈希表 哈希表的数据结构是一个顺序表，在存储内容时通过数组下标与数据值一一映射的方式记录。这里的一一映射关系可以用函数来表示，这样的函数叫.
实现散列查找（数据结构与算法 - 查找）
韶言大雅
04-25 8071
相关知识 本关讨论散列存储，散列函数使用除留余数法，冲突解决方法采用独立链表地址法。假设有 8 个关键码： 7 , 15 , 23 , 31 , 12 , 14 , 10 , 17 ，采用散列函数hash(key)=key%7，其存储结构图如图 1 所示，它由 7 个独立链表组成，散列值相同的关键码在同一个链表里，独立链表的头结点组成散列表，一共 7 行，编号 0 , 1 , … , 6 。独立链...
哈希表的实现
叫我小秦就好了的博客
03-10 1541
二叉搜索树具有对数时间的表现，但这样的表现建立在一个假设上：输入的数据有足够的随机性。哈希表又名散列表，在插入、删除、搜索等操作上具有「常数平均时间」的表现，而且这种表现是以统计为基础，不需依赖输入元素的随机性。
数据结构课设：哈希表实现通讯录
"该文档是关于数据结构课程设计的一份报告，主要任务是制作一个通讯录，使用哈希表来存储班级成员的信息，包括姓名、电话和地址。设计要求平均查找长度不超过特定值R，使用除留余数法构建哈希函数，并通过链地址法或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值