线索二叉树和哈夫曼树

已于 2023-02-18 13:53:45 修改
阅读量685 收藏 4
点赞数 2
分类专栏： 数据结构（王道） 文章标签： 数据结构 算法 c++
于 2022-11-23 00:16:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63783532/article/details/127992468
版权

目录

一、线索二叉树的类型定义

二、各种线索化的二叉树

三、中序线索二叉树的算法

 完整代码

四、有关哈夫曼树的定义

哈夫曼编码

一、线索二叉树的类型定义

typedef struct BTNode
{
    ElemType data;//数据域
    struct BTNode* lchild;//左孩子或线索指针
    struct BTNode* rchild;//右孩子或线索指针
    int ltag, rtag;
}BTNode, * BTree;
  •  左标志ltag=0，表示lchild指向左孩子结点；ltag=1，表示lchild指向前驱结点
  • 右标志rtag=0，表示rchild指向右孩子结点；rtag=1，表示rchild指向后继结点
  • 二叉树线索化的基本思想：
  • 二叉树的线索化实质上是遍历一棵二叉树。在遍历过程中，访问结点的操作是检查此结点的左、右指针域是否为空，如果为空，将它指向其前驱或后继结点的线索

二、各种线索化的二叉树

 

  •  为了操作方便，在存储线索二叉树的时候增设一个头结点，其结构与其他的线索二叉树的结点相同，只是数据域不存储任何数据，其左指针域指向二叉树的根结点，右指针指向遍历的最后一个结点，而二叉树在某种遍历下的第一个结点的前驱和最后一个结点的后继线索都指向头结点。

三、中序线索二叉树的算法

  • 第一种方法建立并且遍历中序线索二叉树： 
//第一种方法
void CreatInThread(BTree &T);建立中序线索树
void InThread(BTree& T);//中序遍历二叉树，一边遍历一边线索化
void visit(BTree& q);//访问根结点
void visit2(BTree T);//遍历输出中序线索二叉树
BTNode* pre = NULL;//定义全局变量

void CreatInThread(BTree& T)//建立中序线索树
{
    pre = NULL;
    if (T != NULL)
    {
        InThread(T);//中序线索化二叉树
        if (pre!=NULL&&pre->rchild == NULL)
        {
            pre->rtag = 1;
        }
    }
}

void InThread(BTree& T)//中序遍历二叉树，一边遍历一边线索化
{
    if (T != NULL)
    {
        InThread(T->lchild);//左子树递归线索化
        visit(T);//访问根结点同时线索化
        InThread(T->rchild);//右子树递归线索化
    }
}

void visit(BTree& q)//访问根结点
{
    if (q->lchild == NULL)//左子树为空的时候，让其前驱线索指向空
    {
        q->lchild = pre;
        q->ltag = 1;
     }
    else
    {
        q->ltag = 0;
    }
    if (pre != NULL && pre->rchild == NULL)
    {
        pre->rchild = q;//建立前驱结点的后继线索（让前驱结点的rchild域存放后继结点的地址）
        pre->rtag = 1;
    }
    else
    {
        q->rtag = 0;
    }
    pre = q;
}

void visit2(BTree T)//遍历中序线索二叉树
{
    BTNode* p = T;
    while (p != NULL)
    {
        while (p->ltag == 0)//找开始结点
        {
            p = p->lchild;
        }
        cout << p->data << " ";//找到中序遍历最开始的结点并输出其data的值
        while (p->rtag == 1 && p->rchild != NULL)
        {
            p = p->rchild;
            cout << p->data << " ";
        }
        p = p->rchild;
    }
    return;
}
  •  第二种方法建立并且遍历中序线索二叉树：
//第二种方法
BTree CreatBTree(BTree& T);//中序线索化二叉树，先创建头结点root
void Thread(BTree& T);//中序线索化二叉树
void ThInOrder(BTree T);//在中序线索化二叉树中实现中序遍历（输出）
BTree CreatBTree(BTree & T)//中序线索化二叉树，先创建头结点root
{
    BTNode* root = (BTNode*)malloc(sizeof(BTNode));//创建一个头结点
    if (root == NULL)
    {
        exit(0);
    }
    root->ltag = 0;
    root->rtag = 1;
    root->rchild = T;
    if (T == NULL)//空二叉树
    {
        root->lchild = root;
    }
    else
    {
        root->lchild = T;//头结点的lchild域存放二叉树根结点的地址
        pre = root;
        Thread(T);//中序线索化二叉树
        pre->rchild = root;//最后处理加入头结点的线索
        pre->rtag = 1;
        root->rchild = pre;//头结点线索化

    }
    return root;
}

void Thread(BTree& T)//中序线索化二叉树
{
    if (T != NULL)
    {
        Thread(T->lchild);//左子树线索化
        if (T->lchild == NULL)
        {
            T->lchild = pre;//建立当前结点的前驱线索
            T->ltag = 1;
        }
        else
        {
            T->ltag = 0;
        }
        if (pre != NULL && pre->rchild == NULL)
        {
            pre->rchild = T;//建立前驱结点的后继线索
            pre->rtag = 1;
        }
        else
        {
            if (pre != NULL)
            {
                pre->rtag = 0;
            }
        }
        pre = T;
        Thread(T->rchild);//右子树线索化
    }
}


void ThInOrder(BTree tb)//tb指向中序线索二叉树的头结点
{
    BTNode* p = tb->lchild;
    while (p != tb)
    {
        while (p->ltag == 0)//找中序二叉树的开始结点（开始结点在最左下方）
        {
            p = p->lchild;
        }
        cout << p->data << " ";
        while (p->rtag == 1 && p->rchild != tb)
            //p->rtag=1并且p->rchild!=头结点表示p结点的rchild域存放的是中序遍历的后继结点的地址（线索）
        {
            p = p->rchild;//沿右线索访问后继结点
            cout << p->data << " ";
        }
        p = p->rchild;//转向p的右子树
    }
       
    
}

  •  完整代码

#pragma once
#include<iostream>
#include<cstdlib>
#include<stdbool.h>
using namespace std;
#define MAXSIZE 100
typedef char ElemType;
typedef struct BTNode
{
    ElemType data;//数据域
    struct BTNode* lchild;//左孩子或线索指针
    struct BTNode* rchild;//右孩子或线索指针
    int ltag, rtag;
}BTNode, * BTree;
 
BTree Creat(char str[]);//先序序列建立二叉链表

void PreOrder(BTree T);//先序遍历
void InOrder(BTree T);//中序遍历
void PostOrder(BTree T);//后序遍历
void LevelOrder(BTree T);//层序遍历


//第一种方法
void CreatInThread(BTree &T);建立中序线索树
void InThread(BTree& T);//中序遍历二叉树，一边遍历一边线索化
void visit(BTree& q);//访问根结点
void visit2(BTree T);//遍历输出中序线索二叉树


//第二种方法
BTree CreatBTree(BTree& T);//中序线索化二叉树，先创建头结点root
void Thread(BTree& T);//中序线索化二叉树
void ThInOrder(BTree T);//在中序线索化二叉树中实现中序遍历（输出）

//找后继结点
bool InPostNode(BTree& s);//寻找中序线索二叉树的的后继结点

#include"TBTree.h"
BTree Creat(char str[])//先序序列建立二叉链表（方法1）
{
    BTree T;
    static int i = 0;
    ElemType c = str[i++];
    if (c == '#')//输入#表示此结点下不存在分支
    {
        T = NULL;
    }
    else
    {
        T = (BTree)malloc(sizeof(BTree));
        if (T == NULL)
        {
            exit(0);
        }
        T->data = c;
        T->lchild = Creat(str);//递归创建左子树
        T->rchild = Creat(str);//到上一个结点的右边递归创建左右子树
    }
    return T;
}

BTNode* pre = NULL;//定义全局变量

void CreatInThread(BTree& T)//建立中序线索树
{
    pre = NULL;
    if (T != NULL)
    {
        InThread(T);//中序线索化二叉树
        if (pre!=NULL&&pre->rchild == NULL)
        {
            pre->rtag = 1;
        }
    }
}

void InThread(BTree& T)//中序遍历二叉树，一边遍历一边线索化
{
    if (T != NULL)
    {
        InThread(T->lchild);//左子树递归线索化
        visit(T);//访问根结点同时线索化
        InThread(T->rchild);//右子树递归线索化
    }
}

void visit(BTree& q)//访问根结点
{
    if (q->lchild == NULL)//左子树为空的时候，让其前驱线索指向空
    {
        q->lchild = pre;
        q->ltag = 1;
     }
    else
    {
        q->ltag = 0;
    }
    if (pre != NULL && pre->rchild == NULL)
    {
        pre->rchild = q;//建立前驱结点的后继线索（让前驱结点的rchild域存放后继结点的地址）
        pre->rtag = 1;
    }
    else
    {
        q->rtag = 0;
    }
    pre = q;
}

bool InPostNode(BTree& s)//寻找中序线索二叉树的的后继结点
{
    BTNode* post;
    post = s->rchild;
    if (s->rtag != 1)//结点s有右孩子
    {
        while (post->ltag == 0)//从右子树的根结点开始，沿左指针域往下查找，
            //直到没有左孩子为止
        {
            post = post->lchild;
        }
    }
    s = post;
    return true;
}


void visit2(BTree T)//遍历中序线索二叉树
{
    BTNode* p = T;
    while (p != NULL)
    {
        while (p->ltag == 0)//找开始结点
        {
            p = p->lchild;
        }
        cout << p->data << " ";//找到中序遍历最开始的结点并输出其data的值
        while (p->rtag == 1 && p->rchild != NULL)
        {
            p = p->rchild;
            cout << p->data << " ";
        }
        p = p->rchild;
    }
    return;
}





BTree CreatBTree(BTree & T)//中序线索化二叉树，先创建头结点root
{
    BTNode* root = (BTNode*)malloc(sizeof(BTNode));//创建一个头结点
    if (root == NULL)
    {
        exit(0);
    }
    root->ltag = 0;
    root->rtag = 1;
    root->rchild = T;
    if (T == NULL)//空二叉树
    {
        root->lchild = root;
    }
    else
    {
        root->lchild = T;//头结点的lchild域存放二叉树根结点的地址
        pre = root;
        Thread(T);//中序线索化二叉树
        pre->rchild = root;//最后处理加入头结点的线索
        pre->rtag = 1;
        root->rchild = pre;//头结点线索化

    }
    return root;
}

void Thread(BTree& T)//中序线索化二叉树
{
    if (T != NULL)
    {
        Thread(T->lchild);//左子树线索化
        if (T->lchild == NULL)
        {
            T->lchild = pre;//建立当前结点的前驱线索
            T->ltag = 1;
        }
        else
        {
            T->ltag = 0;
        }
        if (pre != NULL && pre->rchild == NULL)
        {
            pre->rchild = T;//建立前驱结点的后继线索
            pre->rtag = 1;
        }
        else
        {
            if (pre != NULL)
            {
                pre->rtag = 0;
            }
        }
        pre = T;
        Thread(T->rchild);//右子树线索化
    }
}


void ThInOrder(BTree tb)//tb指向中序线索二叉树的头结点
{
    BTNode* p = tb->lchild;
    while (p != tb)
    {
        while (p->ltag == 0)//找中序二叉树的开始结点（开始结点在最左下方）
        {
            p = p->lchild;
        }
        cout << p->data << " ";
        while (p->rtag == 1 && p->rchild != tb)
            //p->rtag=1并且p->rchild!=头结点表示p结点的rchild域存放的是中序遍历的后继结点的地址（线索）
        {
            p = p->rchild;//沿右线索访问后继结点
            cout << p->data << " ";
        }
        p = p->rchild;//转向p的右子树
    }
       
    
}

void PreOrder(BTree T)//先序遍历
{
    if (T != NULL)
    {
        cout << T->data << " ";//访问根结点
        PreOrder(T->lchild);//先序遍历左子树
        PreOrder(T->rchild);//先序遍历右子树
    }
}

void InOrder(BTree T)//中序遍历
{
    if (T != NULL)
    {
        InOrder(T->lchild);
        cout << T->data << " ";
        InOrder(T->rchild);
    }

}
void PostOrder(BTree T)//后序遍历
{
    if (T != NULL)
    {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        cout << T->data << " ";
    }
}


void LevelOrder(BTree T)//层序遍历
{
    BTNode* p;
    BTNode* qu[MAXSIZE];//定义循环队列，存放结点指针
    int front, rear;//定义头指针和尾指针
    front = rear = 0;//置队列为空队列
    rear++;
    qu[rear] = T;//根结点指针进队
    rear++;//队尾指针指向队尾元素的后一个位置
    front = (front + 1) % MAXSIZE;//队头指针加1取模
    while (front != rear)//队列不为空
    {
        p = qu[front];//取队头元素
        front = (front + 1) % MAXSIZE;//队头元素出队，队头指针后移
        cout << p->data << " ";
        if (p->lchild != NULL)
        {
            qu[rear] = p->lchild;//p结点的左孩子进栈
            rear = (rear + 1) % MAXSIZE;//队尾指针加1取模
        }
        if (p->rchild != NULL)
        {
            qu[rear] = p->rchild;//p结点的右孩子进栈
            rear = (rear + 1) % MAXSIZE;
        }
    }
}

#include"TBTree.h"

int main()
{
	cout << "二叉树建立的第一种方法" << endl;
	BTree T;//T为指向根结点的指针
	T = (BTree)malloc(50*sizeof(BTree));
	char str[] = { 'a','b','d','#','g','#','#','#','c','e','#','#','f','#','#' };
	T = Creat(str);
	cout << "先序遍历结果：";
	PreOrder(T);//先序遍历
	cout << endl;
	cout << "中序遍历结果：";
	InOrder(T);//中序遍历
	cout << endl;
	cout << "后序遍历结果：";
	PostOrder(T);//后序遍历
	cout << endl;
	cout << "层次遍历的结果：";
	LevelOrder(T);
	cout << endl << endl;


	/*cout << "中序线索树遍历结果：";
	CreatInThread(T);
	visit2(T);
	cout << endl << endl;*/


	cout << "中序遍历结果2：";
	BTree tb;
	tb = (BTree)malloc(50*sizeof(BTree));

	tb = CreatBTree(T);
	ThInOrder(tb);
	//system("pause");
	return 0;
}

四、有关哈夫曼树的定义

  • 路径：是指从一个结点到另一个结点之间的分支序列。
  • 路径长度：是指从一个结点到另一个结点所经过的分支数目。
  • 哈夫曼树：也称最优二叉树，是指对于一组带有确定权值的叶结点，构造的具有最小带权路径长度的二叉树

  • 哈夫曼树的构造步骤：

给定n个权值分别为w1，w2...wn的结点
1.将这n个结点分别作为n棵仅含一个结点的二叉树，构成森林F
2.构造一个新的结点，从F中选取两棵根结点权值最小的树作为新结点的左，右子树，并且将
新结点的权值置为左、右子树上根结点的权值之和。
3.从F中删除刚才选出的两棵树，同时将新得到的树加入F中。
4.重复步骤2和3，直至F中只剩下一棵树为止。 

 

哈夫曼编码

  • 固定长度编码：每个字符用相等长度的二进制位表示

例如：A--00；B--01；C--10；D--11

  • 可变长度编码：允许对不同字符用不等长的二进制位表示

例如：C--0；A--10；B--111；D--110

  • 前缀编码：若没有一个编码是另一个编码的前缀，则称这样的编码为前缀编码

由哈夫曼树得到的哈夫曼编码--字符集中每个字符作为一个叶子结点，各个字符出现的频度作为
结点的权值。
 

莫忘、莫念
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法课程笔记（九）
Motseturtle的博客
04-24 6148
实验九 线索二叉树和哈夫曼树一、实验目的二、实验环境三、实验内容和步骤 一、实验目的 掌握二叉树的线索化及其应用 掌握构造哈夫曼树及哈夫曼编码 二、实验环境 Windows 7以上版本的操作系统，Visual Studio 2010以上编程环境。 三、实验内容和步骤 实验预备知识：线索二叉树 已知一颗二叉树的前序遍历序列为： AB#CD##E##F#G## （#号指示空指针位置） 画出这颗二叉树。 该二叉树如下图所示： 根据画出的二叉树写出另外两个遍历序列： 中序遍历序列为 BDCEAFG
线索二叉树详细解释
ybbgrain的历程
09-26 2013
全知识整理目录 数据结构整理的目录包括了许多的数据结构相关知识。 概述 什么是线索二叉树？ 为了区分二叉树的左孩子指针，和右孩子指针是否为空，为结点增加了2个域，这两个域分别是Ltag和Rtag。这样的二叉树，就是线索二叉树。 需要了解的概念 如果结点有左孩子：那么Lchild指向他的左孩子，否则指向遍历序列中他的前驱结点。 如果结点有右孩子：那么Rchild依然指向他的左孩子，否则指向遍历序列的后继节点。 Ltag=0：表示Lchild指向结点的左孩子。 Ltag=1：表示Lc.
数据结构与算法之二叉树+遍历+哈夫曼树
chenliguan的博客
10-28 3486
1 概念 1.1 二叉树概念 　　 二叉树是一种非常重要的数据结构，它同时具有数组和链表各自的特点：它可以像数组一样快速查找，也可以像链表一样快速添加。但是他也有自己的缺点：删除操作复杂。 1.2 二叉树分类 （1） 二叉树：二叉树(binary tree)是一棵树是每个结点最多有两个子树的有序树，在使用二叉树的时候，数据并不是随便插入到节点中的。 （2） 完全二叉树：若设二叉...
【数据结构】建立二叉树以及哈夫曼树及哈夫曼编码
专注于Java领域开发 关注我 带你玩转Java
09-12 1621
建立二叉树以及哈夫曼树及哈夫曼编码
8. 二叉树和哈夫曼树-数据结构入门(c语言实现)
qq_59959075的博客
06-26 928
二叉树由一个根节点和两棵互不相交的称为左子树和右子树的二叉树组成。
哈夫曼树和线索二叉树的实现
11-19
哈夫曼树和线索二叉树的实现 哈夫曼树是一种特殊的二叉树，它的权值最小，可以用来构建哈夫曼编码。哈夫曼树的实现主要通过选择两个双亲域为0且权值最小的结点，合并成一个新的结点，直到所有叶子结点都被合并成一...
数据结构实验实现中序线索化二叉树构造哈夫曼树.doc
10-08
本实验报告的主要内容是实现中序线索化二叉树构造哈夫曼树，通过实验实现了解二叉树的基本概念和哈夫曼树的构造过程。 一、实验背景 二叉树是数据结构中的一种重要数据结构形式，它广泛应用于计算机科学和信息技术...
二叉树、哈夫曼树课件
05-04
1.二叉树的线索化过程以及在中序线索化树上找给定结点的前驱和后继的方法 2.哈夫曼树的定义、哈夫曼树的构造过程和哈夫曼编码产生方法
二叉树(二叉树遍历,线索二叉树,哈夫曼树,树,森林)
09-27
二叉树(二叉树遍历,线索二叉树,哈夫曼树,树,森林)代码和讲解,内容详细全面,通俗易懂,通过测试,代码可以直接使用,方便大家学习.
树和二叉树
05-22
主要知识点 树的基本概念和存储结构 二叉树的基本概念 二叉树的性质 二叉树的操作实现 二叉树的遍历 线索二叉树的概念和设计方法 哈夫曼树的概念和设计方法 树与二叉树的转换方法
线索二叉树以及哈夫曼树
qq_43750656的博客
08-12 373
线索二叉树分为中序线索二叉树，前序线索二叉树，后序线索二叉树。中序线索二叉树就是根据中序遍历的结果,把中序遍历的结果看成一个线性表，对于线性表来说，每一个节点都会有一个前驱节点和一个后继节点。上图二叉树的中序遍历结果是：DBAGECF。D没有前驱节点，F没有后继节点。如果想找一个节点的前驱节点，例如想找E的前驱节点，只能从根节点开始再进行一次中序遍历，用两个指针，一个指向当前节点，一个指向当前节点的上一个遍历的节点。对普通二叉树结构进行改造，升级为线索二叉树。...
二叉树与哈夫曼树
xiezhihua261的博客
11-15 1818
1，二叉树           二叉树可以分为：完全二叉树，满二叉树，哈夫曼树；           二叉树的遍历：（递归）先序，中序，后序遍历；           二叉树的结构：根节点，左子树，右子树；           二叉树的性质：                  (1). 如果二叉树的节点个数为n,则父节点的个数为n/2;                 (2
数据结构-树和二叉树-Huffman树
Magicapprentice的博客
09-27 1810
树和二叉树 Huffman 树 赫夫曼（Huffman)树，又称最优树，是一类带权路径长度最短的树，有着广泛的应用。 路径:从树中一个结点到另一个结点之间的分支构成这两个结点之间的路径。 路径长度：路径上分支的数目构成路径长度。 树的路径长度：树根到每一个节点的路径长度之和。 树的带权路径长度：树中所有叶子节点的带权路径长度之和，记作WPL=∑k=1nwklkWPL = \sum_{k=1}^{n}w_kl_kWPL=∑k=1n​wk​lk​ 最优二叉树或赫夫曼树:假设有n个权值{w,w,...,w.}\l
学习数据结构--第四章：树与二叉树（二叉排序树、二叉平衡树、哈夫曼树）
理木客
06-03 1861
第四章：树与二叉树（树与二叉树的应用）
第六章树和二叉树--Huffman树
刘二狗的博客
11-08 6608
1-1 对N（≥2）个权值均不相同的字符构造哈夫曼树，则树中任一非叶结点的权值一定不小于下一层任一结点的权值。 (2分) T  2-1 对N（N≥2）个权值均不相同的字符构造哈夫曼树。下列关于该哈夫曼树的叙述中，错误的是： (2分) 树中一定没有度为1的结点 树中两个权值最小的结点一定是兄弟结点 树中任一非叶结点的权值一定不小于下一层任一结点的权值 该树一定是一棵完全二叉树 2-2...
哈夫曼树与哈夫曼编码
Y_23k_bug的专栏
07-26 5851
在一般的数据结构的书中，树的那章后面，著者一般都会介绍一下哈夫曼(HUFFMAN) 树和哈夫曼编码。哈夫曼编码是哈夫曼树的一个应用。哈夫曼编码应用广泛，如 JPEG中就应用了哈夫曼编码。 首先介绍什么是哈夫曼树。哈夫曼树又称最优二叉树， 是一种带权路径长度最短的二叉树。所谓树的带权路径长度，就是树中所有的叶结点 的权值乘上其到根结点的 路径长度（若根结点为0层，叶结点到根结
树与二叉树——哈夫曼树及哈夫曼编码
fu_jian_ping的博客
03-27 522
哈弗曼树的有关概念和定义这里省略，这里主要是展示如何用代码构造哈夫曼树以及哈夫曼编码。 #include <stdio.h> #define SIZE 5 /*假设字符集中有5个字符*/ typedef struct /*定义哈夫曼树的结点结构*/ { in...
二叉树构造、线索二叉树、哈夫曼树、并查集
weixin_30248399的博客
08-31 213
中序先序构造 BTNode* CreateBT(char* pre, char* in, int n) { char* p; BTNode* b; int k; if (n <= 0) return NULL; b = (BTNode*)malloc(sizeof(BTNode)); b->data = *pre; for (p = ...
【数据结构】哈夫曼树（最优二叉树）和哈夫曼编码
Jacky_Feng的博客
09-08 1773
一、专业术语 路径 在一棵树中，从一个结点到另一个结点所经过的所有结点，被我们称为两个结点之间的路径。 示例图中根结点A到叶结点D的路径为A、B、D 路径长度 在一棵树中，从一个结点到另一个结点所经过的“边”的数量，被我们称为两个结点之间的路径长度。 示例图中根结点A到叶结点D经过了3条边，所AD的路径长度为3 权 将节点赋予一定的量值，该量值成为权。 结点的带权路径长度 树的每一个结点，都可以拥有自己的“权重”（Weight），权重在不同的算法当中可以起到不同的作用。 ...
最优搜索二叉树和哈夫曼树的区别
最新发布
12-22
因此，最优搜索二叉树和哈夫曼树的区别主要体现在应用场景和构建方式上。最优搜索二叉树用于提高搜索效率，构建方式基于已知的键值和搜索频率；而哈夫曼树用于数据压缩，构建方式基于字符或字符集合的权重。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值