C语言迅速上手哈夫曼树与哈夫曼编码

已于 2022-11-24 12:42:14 修改
阅读量641 收藏 12
点赞数
文章标签： 算法 数据结构
于 2022-11-23 23:24:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61821927/article/details/128009520
版权

哈夫曼树可以说是最经典的一类二叉树了，它出现的频率很高，也有广泛的应用。

哈夫曼树的建立虽然不算太难，但笔者在初次接触并实现对应的操作时却也遇到了一些困难，所以在这就分享一些个人的经验与见解，希望对初学者刚刚接触哈夫曼树能起到一定的帮助。

关于哈夫曼树的动态生成的原理，很多优秀的博客都有详细的讲解，下面推荐一篇非常好的博客，用大量的图片gif素材可视化地展现了整个过程，大家可以参考着上手理解。

(29条消息) 哈夫曼树（C语言实现）_2021dragon的博客-CSDN博客_哈夫曼树c语言

其实哈夫曼树的原理并不难理解，相信大家通过这个博客能很快上手，我们就从具体代码的角度进行分析。

其实建哈夫曼树的步骤并不复杂，虽然它的单个结点定义量可能比较多（权值，字符值，父节点，左右孩子结点），但是核心只有一个：每次选择权值较小的两个结点值，合并生成新树（新的结点），并且动态更新结点的父节点与孩子节点的值。

在此之前，我们只需要用一个数组存储所有结点的权值（在这里面的字符值其实是可有可无的），并且对未建树前的结点进行简单的初始化（parent，ichlid，rchild赋值0）。在动态更新后续产生的新结点时，会对选择的结点进行parent的重新更新。

下面是建立哈夫曼树的核心代码。

void Create_HuffmanTree(HuffmanTree &HT,int n,int *w)
{
	int m,s1,s2;
	m=2*n-1;
	HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
	for(int j=0;j<=m;j++)
	{
		HT[j].parent=HT[j].lchild=HT[j].rchild=0;
	}
	for(int j=1;j<=n;j++)
	{
		HT[j].weight=w[j-1];
	}
	for(int i=n+1;i<=m;i++)
	{
		Select(HT,i-1,s1,s2);
		HT[s1].parent=i;
		HT[s2].parent=i;
		HT[i].lchild=s1;
		HT[i].rchild=s2;
		HT[i].weight=HT[s1].weight+HT[s2].weight;
	}
	
}

   注意，我们用了动态分配空间，对于n个结点的树，最终产生的哈夫曼树会有2n-1个结点（进行n-1次合并，每次合并会减少一棵子树），而我们为了方便，我们HT是从下标为1开始存储值的。这个时候我们需要注意分配空间时要分配m+1个HTNode（我曾经因为这个疏忽，耗费了大量时间进行测试，但是一直出现运行的错误但却不知道原因）。

这里面还有一个重要的函数Select，它的作用就是挑出原结点里权值最小的两个（并且之前没有被挑中过的），然后返回它们的下标s1，s2。

这个函数的写法可以有很多，本质就是一个排序函数，只是我们只需要得到值最小的两个。

我们可以利用排序使之有序化，但是这样太浪费了。所以，我选择的是简单的扫描比对找出两个最小的。

Select函数如下。

void Select(HuffmanTree HT,int i,int &s1,int &s2)
{
	int min1,min2;
	for(int j=1;j<=i;j++)
	{
		if(HT[j].parent==0)
		{
			min1=j;
			break;
		}
	}
	for(int j=min1+1;j<=i;j++)
	{
		if(HT[j].parent==0)
		{
			if(HT[j].weight<HT[min1].weight)
			min1=j;
		}
	}
	for(int k=1;k<=i;k++)
	{
		if(HT[k].parent==0 && k!=min1)
		{
			min2=k;
			break;
		}
	}
	for(int k=min2+1;k<=i;k++)
	{
		if(HT[k].parent==0)
		{
			if(HT[k].weight<HT[min2].weight && k!=min1)
			min2=k;
		}
	}
	s1=min1;
	s2=min2;
	
}

这就是这部分的核心代码。

但是哈夫曼树的建立，往往就会与哈夫曼编码紧密关联。所以，在这里笔者也给出对应的哈夫曼编码的代码分析。

哈夫曼编码的原理同样可以参考上面的博客，本质就是在哈夫曼树上，以根节点出发，向下延伸到某一结点的过程中，对之路径上进行对应的编码。我们一般左子树为0，右子树为1（颠倒并不影响）。这样，根据权值（一般代表频率），可以得到最高效的二进制编码。

在代码中，我们设定char**为HuffmanCode的类型，原因是HuffmanCode是一个字符指针数组，他的每一个元素同样是字符指针，指向一个存储对应哈夫曼编码的字符数组。

代码如下。

void Create_HuffmanCode(HuffmanCode &HC,HuffmanTree &HT,int n)
{
	HC=(HuffmanCode)malloc((n+1)*sizeof(char*));
	char *cd;
	cd=(char*)malloc(n*(sizeof(char)));
	cd[n-1]='\0';
	int start,p,c;
	for(int i=1;i<=n;i++)
	{
		start=n-1;
		c=i;
		p=HT[c].parent;
		while(p)
		{
			if(HT[p].lchild==c)
			cd[--start]='0';
			else
			cd[--start]='1';
			c=p;
			p=HT[c].parent;
		}
		HC[i]=(char*)malloc((n-start)*(sizeof(char)));
		strcpy(HC[i],&cd[start]);
	}
	free(cd);
	
	
 }

其中malloc与free函数可以置换成new与delete，我们将编码先存放在cd数组里，最后根据cd数组长度为HC的每一个字符指针指向的数组动态分配空间，再用strcpy函数将内容复制到HC中。

里面start记录了编码位数，c代表循环里当前结点，p是其父节点，一直循环走下去，直到碰到根结点结束，路径终止，编码结束。

也不太难理解是吧。

其实哈夫曼树与编码并不抽象，属于比较简单的，但是也需要我们去用心揣测背后的细节，才能做到熟练掌握。

下面贴出全部代码，便于进行用例测试。

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include<string.h>
using namespace std;
#define MAX 100
#define status int
#define ElemType char 

typedef struct
{
	int weight;
	int parent,lchild,rchild;
}HTNode,*HuffmanTree;

typedef char **HuffmanCode;

void input_weitht(int *w,int n)
{
	cout<<"输入哈夫曼树结点的权值"<<endl; 
	for(int j=0;j<n;j++)
	{
		cin>>w[j];
	}
}


void Select(HuffmanTree HT,int i,int &s1,int &s2)
{
	int min1,min2;
	for(int j=1;j<=i;j++)
	{
		if(HT[j].parent==0)
		{
			min1=j;
			break;
		}
	}
	for(int j=min1+1;j<=i;j++)
	{
		if(HT[j].parent==0)
		{
			if(HT[j].weight<HT[min1].weight)
			min1=j;
		}
	}
	for(int k=1;k<=i;k++)
	{
		if(HT[k].parent==0 && k!=min1)
		{
			min2=k;
			break;
		}
	}
	for(int k=min2+1;k<=i;k++)
	{
		if(HT[k].parent==0)
		{
			if(HT[k].weight<HT[min2].weight && k!=min1)
			min2=k;
		}
	}
	s1=min1;
	s2=min2;
	
}

void Create_HuffmanTree(HuffmanTree &HT,int n,int *w)
{
	int m,s1,s2;
	m=2*n-1;
	HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
	for(int j=0;j<=m;j++)
	{
		HT[j].parent=HT[j].lchild=HT[j].rchild=0;
	}
	for(int j=1;j<=n;j++)
	{
		HT[j].weight=w[j-1];
	}
	for(int i=n+1;i<=m;i++)
	{
		Select(HT,i-1,s1,s2);
		HT[s1].parent=i;
		HT[s2].parent=i;
		HT[i].lchild=s1;
		HT[i].rchild=s2;
		HT[i].weight=HT[s1].weight+HT[s2].weight;
	}
	
}

void Create_HuffmanCode(HuffmanCode &HC,HuffmanTree &HT,int n)
{
	HC=(HuffmanCode)malloc((n+1)*sizeof(char*));
	char *cd;
	cd=(char*)malloc(n*(sizeof(char)));
	cd[n-1]='\0';
	int start,p,c;
	for(int i=1;i<=n;i++)
	{
		start=n-1;
		c=i;
		p=HT[c].parent;
		while(p)
		{
			if(HT[p].lchild==c)
			cd[--start]='0';
			else
			cd[--start]='1';
			c=p;
			p=HT[c].parent;
		}
		HC[i]=(char*)malloc((n-start)*(sizeof(char)));
		strcpy(HC[i],&cd[start]);
	}
	free(cd);
	
	
 } 

void Show(HuffmanTree HT,int n)
{
	int m=2*n-1;
	cout<<"依次输出序号，weight，parent，lchild，rchild"<<endl;
	for(int j=1;j<=m;j++)
	{
		cout<<"\t"<<j<<"\t";
		cout<<HT[j].weight<<"\t";
		cout<<HT[j].parent<<"\t";
		cout<<HT[j].lchild<<"\t";
		cout<<HT[j].rchild<<endl;
	 
	}
}

void show(HuffmanCode HC)
{
	for(int i=1;i<=sizeof(HC);i++)
	{
		cout<<"序号为"<<i<<"的编码为：";
		cout<<HC[i]<<endl;
	}
}


int main()
{
	HuffmanTree HT;
	HuffmanCode HC;
	int n;
	cin>>n;
	int w[MAX];
	input_weitht(w,n);
	Create_HuffmanTree(HT,n,w);
	Create_HuffmanCode(HC,HT,n);
	Show(HT,n);
	show(HC);
	
	
}

里面的Show与show函数是简单的输出一下树结点与对应编码。

插入运行结果。

希望对大家有所帮助。 

今天在完成老师的项目实验时，补充一段更加详细的代码吧，包含哈夫曼树的建立、编码以及译码的全过程，以菜单的形式展示。

与上面多出来的就是哈夫曼编码的破译函数。

void Encoding(HuffmanTree HT,char *s)
{
	Get_Str(s);
	int p;
	cout<<"译码后的字符串为：";
	while(*s!='\0')
	{
		p=2*n-1;
		while(HT[p].lchild!=0 || HT[p].rchild!=0)
	{
		if(*s=='0')
		p=HT[p].lchild;
		else
		p=HT[p].rchild;
		s++;
	}
	cout<<HT[p].data;
	}
	cout<<endl;
}

破译的过程比较简单，就是基于已经建好的哈夫曼树，实质就是编码的逆过程。

我们从根节点开始，向下遍历，当编码为0时探索左子树，当编码为1时探索右子树，直到进入了孩子结点，该段编码被破译，此时返回的p就是对应的结点下标，我们直接输出其字符值即可。

其中参考我们建立哈夫曼树的过程，最终的根节点的下标是2n-1，也就是每轮循环p的初始值（没次破译一个字符后重新从根节点重复上述过程），直到编码末尾。

贴上一段项目完整代码，这里面内容会更加详细一些，包含了上面讲解的所有函数，感兴趣的小伙伴可以借助这段代码整体理解哈夫曼树里的一系列操作。

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include<string.h>
using namespace std;
#define MAX 100
#define status int
#define ElemType char 

typedef struct
{
	char data;
	int weight;
	int parent,lchild,rchild;
}HTNode,*HuffmanTree;

typedef char **HuffmanCode;
int n;

int get_num()
{
	int n;
	cout<<"输入结点个数,最大为100"<<endl;
	cin>>n;
	if(n<0 || n>100)
	{
		cout<<"个数不符合要求，请重新输入"; 
		get_num();
		return 0;
	}
	return n;
}
void input_weitht(int *w,int n)
{
	cout<<"输入哈夫曼树结点的权值"<<endl; 
	for(int j=0;j<n;j++)
	{
		cin>>w[j];
	}
}

void input_data(int n,char *data)
{
	char ch;
	cout<<"输入哈夫曼树对应字符的值"<<endl;
	for(int j=1;j<=n;j++)
	{
		cin>>ch;
		data[j]=ch;
	}
}

void Select(HuffmanTree HT,int i,int &s1,int &s2)
{
	int min1,min2;
	for(int j=1;j<=i;j++)
	{
		if(HT[j].parent==0)
		{
			min1=j;
			break;
		}
	}
	for(int j=min1+1;j<=i;j++)
	{
		if(HT[j].parent==0)
		{
			if(HT[j].weight<HT[min1].weight)
			min1=j;
		}
	}
	for(int k=1;k<=i;k++)
	{
		if(HT[k].parent==0 && k!=min1)
		{
			min2=k;
			break;
		}
	}
	for(int k=min2+1;k<=i;k++)
	{
		if(HT[k].parent==0)
		{
			if(HT[k].weight<HT[min2].weight && k!=min1)
			min2=k;
		}
	}
	s1=min1;
	s2=min2;
	
}

void Create_HuffmanTree(HuffmanTree &HT,int n,int *w,char *data)
{
	int m,s1,s2;
	m=2*n-1;
	HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));
	input_data(n,data);
	for(int j=1;j<=n;j++)
	{
		HT[j].data=data[j];
	}
	for(int j=0;j<=m;j++)
	{
		HT[j].parent=HT[j].lchild=HT[j].rchild=0;
	}
	for(int j=1;j<=n;j++)
	{
		HT[j].weight=w[j-1];
	}
	for(int i=n+1;i<=m;i++)
	{
		Select(HT,i-1,s1,s2);
		HT[s1].parent=i;
		HT[s2].parent=i;
		HT[i].lchild=s1;
		HT[i].rchild=s2;
		HT[i].weight=HT[s1].weight+HT[s2].weight;
	}
	
}

void Create_HuffmanCode(HuffmanCode &HC,HuffmanTree &HT,int n)
{
	HC=(HuffmanCode)malloc((n+1)*sizeof(char*));
	char *cd;
	cd=(char*)malloc(n*(sizeof(char)));
	cd[n-1]='\0';
	int start,p,c;
	for(int i=1;i<=n;i++)
	{
		start=n-1;
		c=i;
		p=HT[c].parent;
		while(p)
		{
			if(HT[p].lchild==c)
			cd[--start]='0';
			else
			cd[--start]='1';
			c=p;
			p=HT[c].parent;
		}
		HC[i]=(char*)malloc((n-start)*(sizeof(char)));
		strcpy(HC[i],&cd[start]);
	}
	free(cd);
	
	
 }
 
void Get_Str(char *s)
{
	cout<<"请输入要编码的字符串"<<endl;
	cin>>s; 
}

void Encoding(HuffmanTree HT,char *s)
{
	Get_Str(s);
	int p;
	cout<<"译码后的字符串为：";
	while(*s!='\0')
	{
		p=2*n-1;
		while(HT[p].lchild!=0 || HT[p].rchild!=0)
	{
		if(*s=='0')
		p=HT[p].lchild;
		else
		p=HT[p].rchild;
		s++;
	}
	cout<<HT[p].data;
	}
	cout<<endl;
}   
 
void show(HuffmanCode HC,HuffmanTree HT)
{
	for(int i=1;i<=sizeof(HC);i++)
	{
		cout<<HT[i].data<<"的编码为：";
		cout<<HC[i]<<endl;
	}
}

void Show(HuffmanTree HT,int n)
{
	int m=2*n-1;
	cout<<"依次输出序号，字符，weight，parent，lchild，rchild"<<endl;
	for(int j=1;j<=m;j++)
	{
		cout<<"\t"<<j<<"\t";
		cout<<HT[j].data<<"\t";
		cout<<HT[j].weight<<"\t";
		cout<<HT[j].parent<<"\t";
		cout<<HT[j].lchild<<"\t";
		cout<<HT[j].rchild<<endl;
	 
	}
}

void Init_HuffmanTree(HuffmanTree &HT)
{
	int w[MAX];
	char data[MAX];
	n=get_num();
	input_weitht(w,n);
	Create_HuffmanTree(HT,n,w,data);
	
}


void sight()
{
	cout<<"输入对应的操作数，0代表退出菜单"<<endl;
	cout<<"1.初始化"<<endl;
	cout<<"2.输出哈夫曼树"<<endl;
	cout<<"3.输出哈夫曼编码"<<endl;
	cout<<"4.译码"<<endl;
}

void Blank()
{
	cout<<endl<<"/**********************/"<<endl;
}

void menu()
{
	HuffmanTree HT;
	HuffmanCode HC;
	char s[MAX];
    sight(); 
	int m;
	cin>>m;
	while(m)
	{
		switch(m)
		{
			case 1:Init_HuffmanTree(HT);
		    break;
		    case 2:Show(HT,n);
		    break;
		    case 3:Create_HuffmanCode(HC,HT,n);
		    show(HC,HT);
		    break;
		    case 4:Encoding(HT,s);
		}
		Blank();
		sight();
		cin>>m;
	}
 }
 
 int main()
 {
 	menu();
  }

向前进吧
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
C语言版的哈夫曼树.zip
11-10
哈夫曼树通过构建一种特殊的二叉树来实现字符的高效编码，使得频度较高的字符具有较短的编码，从而提高压缩效率。 在C语言中实现哈夫曼树，首先需要理解二叉树的基本概念。二叉树是一种每个节点最多有两个子节点的...
C语言编码哈夫曼树
06-24
void HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int num)//w存放n个字符的权值（均>0），构造哈夫曼树HT，并求出n个字符的哈弗曼编码HC { int i,m,c,s1,s2,start,f; HuffmanTree p; char* cd; if...
哈夫曼树及哈夫曼树的编码解码
ZERO_IT_C的博客
05-11 2753
总节点n = x + y = 边数 + 1 = my + 1 -> x = (x - 1) / (m - 1) -> n = x + y = (m*x - 1) / (m - 1)总节点数n = (m*x - 1) / (m - 1) // x为叶子数，m为非叶子节点度数。哈夫曼树又称最优树，它是带权路径长度最小的树，它仅有度为m和度为0的节点（叶子）。②每次选取频度最小的两个字符，分别作为左、右孩子（权重为频度）， O（n）选取1、2，作为左、右孩子，3作为父母节点。
6-2 哈夫曼编码
qq_63164238的博客
05-28 1755
函数Select (HuffmanTree HT,int len,int &s1,int &s2)是从1到len中找出parent为0的且权值最小的节点编号赋给s1,s2,（s1的节点编号小于s2），函数void CreatHuffmanTree(HuffmanTree &HT,int n)是构造哈夫曼树，函数void CreatHuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)计算哈夫曼编码。 函数接口定义： void
哈夫曼树（HuffmanTree）详解
qq_42475914的博客
11-22 1万+
目录 1.哈夫曼算法 2.举例说明，感性认识哈夫曼算法，根据上面的4步得出下表 3.结点结构体类型的定义 4.select函数的编写  5.哈夫曼树的创建及编码的创建 6.解码 7. 打印哈夫曼树和哈夫曼编码 8.完整代码 9.运行截图 1.哈夫曼算法 1.根据给定的n个权值{w1,w2,...,wn}构造n棵二叉树的集合F={T1,T2,...,Tn}，其中每棵二叉树Ti...
哈夫曼树
Xuan_m_o的博客
11-21 729
#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> typedef struct { char ch;//字母与编码 int weight;//权重 int parent,lchild,rchild;//父母与左右孩子 }HTNode,*Huff...
哈夫曼树与哈夫曼编码介绍.zip
最新发布
04-18
总结来说，哈夫曼树与哈夫曼编码是优化数据处理和传输效率的有效工具，它们通过构建特定的树形结构并生成对应的编码，实现了对数据的高效压缩和快速访问，是计算机科学和信息技术领域不可或缺的基础知识。
C语言-基于哈夫曼树的数据压缩算法.zip
11-15
哈夫曼编码是一种高效的数据压缩算法，它利用了字符出现频率的不同来构建特殊的二叉树——哈夫曼树（Huffman Tree），进而为每个字符分配一个唯一的二进制编码，频繁出现的字符会得到较短的编码，不常出现的字符则...
数据结构（C语言）-哈夫曼（Huffman）树编码译码操作
热门推荐
qq_44025638的博客
11-17 1万+
huffman树的编码和译码操作
Huffman树及编码（C语言）
11-29
Huffman编码Huffman编码Huffman编码
哈夫曼树 基于C语言的数据结构代码
06-07
哈夫曼树，基于C语言的数据结构程序代码。
C语言 哈夫曼树编码、译码、输出。
qq_51690014的博客
02-17 7969
使用下标模拟指针和结构体指针构建哈夫曼树。
哈夫曼树与哈夫曼编码
m0_61548909的博客
06-04 2026
哈夫曼树的重要定理 对于具有n个叶子节点的哈夫曼树，一共需要2*n-1个节点。。因为对于二叉树来说，有3种类型节点，即度数（节点拥有的子树的个数被称为节点的度）为2的节点，和度数为1的节点和度数为0的节点。而哈夫曼树的非叶子节点都是由两个节点合并产生，所以不会出现度数为1的节点。而生成的非叶子节点的个数为叶子节点个数-1，因此n个叶子节点的哈夫曼树，一共需要2*n-1个节点。 构建哈夫曼树1.初始化：首先申请2n个单元，然后循环2n-1次，从1号单元开始，依次将1至2n-1所有单元中的双亲，左右孩子的下
c 语言解码程序哈夫曼树,哈夫曼树编码|Huffman编码 C源码
weixin_34310322的博客
05-17 225
#include#include#includetypedef struct {int weight;int parent, lchild, rchild;char charr;} HTNode, *HuffmanTree;typedef char **HuffmanCode;void Select(HuffmanTree HT, int i, int *s1, int *s2) {int j, ...
二叉树的应用—Huffman编码与译码 哈夫曼树
qq_54008392的博客
12-05 2881
实验五：二叉树的应用—Huffman编码与译码 实验目的：熟练掌握二叉树的基本操作操作，应用二叉树的结构解决实际问题，熟练掌握Huffman树和Huffman编码的构造方法。 实验内容：设计实现Huffman树的创建算法，并利用Huffman树进行编码和译码。 要求：1.在“Huffman编码“基础上的实现译码操作如输入“10010”译出相应的字符。 2.选做：(1)增加统计原文中各字符权值的功能,(2)将原文进行编码。 代码阅读：表达式树的创建与求值。 //算法5.11 根据赫夫曼树求赫夫曼
数据是怎么被压缩的
houzl的专栏
06-30 526
回答问题之前先来看看什么是压缩。当你有天走在路上，碰见熟人对你说：“吃了？”你一定知道他是在打招呼，既不是要请客也不是让你“没吃赶紧回家吃去”。这一句简单的“吃了”是礼貌和问好的体现，也是一种信息的压缩。笼统地说，把一系列已有信息通过一定方法处理，使得其长度缩短，并且信息含量基本或者完全不变，就称之为压缩。 计算机上的压缩过程我们都知道，计算机采用的是2进制系统。一个连续的n位二进制数
fjnu 1681 Entropy
异ﾘ度ｭ空ｳ間（镜像站）
07-02 843
DescriptionAn entropy encoder is a data encoding method that achieves lossless data compression by encoding a message with “wasted” or “extra” information removed. In other words, entropy encoding
C语言哈夫曼树与哈夫曼编码
09-12
在C语言中实现哈夫曼树和哈夫曼编码，可以按照以下步骤进行： 1. 统计字符的出现频率：遍历待压缩的数据，统计每个字符的出现频率。 2. 构建哈夫曼树：根据字符的出现频率构建哈夫曼树。可以使用最小堆（min heap...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

向前进吧

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值