二叉树的遍历（前序、中序、后序、层序），递归和非递归实现

最新推荐文章于 2022-06-27 16:51:46 发布
最新推荐文章于 2022-06-27 16:51:46 发布
阅读量1k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 二叉树 遍历 非递归 层序遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wjimin2008/article/details/21236953
本文详细介绍了二叉树的遍历方法，包括先序、中序、后序及层序遍历，并提供了非递归实现的代码示例。重点阐述了如何利用栈来解决递归问题，提高程序的效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

其实自己没有写博客的习惯，就是个小菜鸟。因为接下来要找工作的原因，将之前学习过数据结构或者算法温习一下，记录下来，日后回头看看自己当初的稚嫩和不成熟。

树是常用的数据结构，二叉树是最简单的一种树，没有其他树（排序树、红黑树等）的约束，树的遍历也是各大公司笔试时的常见考点。


二叉树的结构定义如下:

struct BinaryTreeNode
{
	int m_nValue;                                       //结点的值
	BinaryTreeNode* m_pLeft;                            //结点的左子树
	BinaryTreeNode* m_pRight;                           //结点的右子树

	//为了接下来的编程的方便，我给了一个带参数的构造函数
	BinaryTreeNode(int val)
	{
		m_nValue=val;
		m_pLeft=NULL;
		m_pRight=NULL;
	}
};

先序遍历或者叫先根遍历，就是先从根结点开始访问，接着访问左子树、最后访问右子树。

所以，先序遍历的顺序是1、2、4、5、6、7、3

中序遍历或者叫中根遍历，就是先从左子树开始访问，接着访问根结点，最后访问右子树。

所以，中序遍历的顺寻是4、2、6、5、7、1、3

后序遍历或者叫后根遍历，就是先从左子树开始访问，接着访问右子树，最后访问根结点。

所以，中序遍历的顺寻是4、6、7、5、2、3、1

所谓的先序、中序、后序都是相对根结点而言的。

最后说一下层序遍历，顾名思义，就是一层一层访问，层序遍历的顺序是，1、2、3、4、5、6、7。

上数据结构课的时候，讲到树这一章，老师开篇明义就说到，树的问题95%都可以用递归解决（当时还不明白怎么一回事，但是这句话我记住了）。

先给出二叉树的结构不管是先序、中序、后序其实就是先访问根结点还是先访问子树的问题，就是一个递归的问题。首先给出递归实现，很简单，只想说一点，既然是递归实现，就一定要有一个终止条件。

void Visit(BinaryTreeNode* pNode)
{
	if(pNode!=NULL)
		printf("%d\t",pNode->m_nValue);
}
void PreOrderRecursion(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)               //终止条件
		return ;

	/*
	先序遍历就是先访问根结点，
	然后访问左子树，
	最后访问右子树
	*/
	Visit(pRoot);
	PreOrderRecursion(pRoot->m_pLeft);
	PreOrderRecursion(pRoot->m_pRight);
}

void InOrderRecursion(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)               //终止条件
		return ;

	/*
	中序遍历就是先访问左子树，
	然后访问根结点，
	最后访问右子树
	*/
	InOrderRecursion(pRoot->m_pLeft);
	Visit(pRoot);	
	InOrderRecursion(pRoot->m_pRight);
}

void PostOrderRecursion(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)               //终止条件
		return ;

	/*
	后序遍历就是先访问左子树，
	然后访问右子树，
	最后访问根结点
	*/
	PostOrderRecursion(pRoot->m_pLeft);
	PostOrderRecursion(pRoot->m_pRight);
	Visit(pRoot);	
}

递归实现最大的好处就是简洁清晰，几行代码就可以实现遍历。但是递归有一个很大的问题，递归需要系统堆栈，一系列函数和返回中所涉及到的参数传递和返回值，都要占用大量系统资源和空间，如果递归的深度很大时，系统根本支撑不了。

递归器在本质上就是堆栈。我们应该记住一句话，一般尾递归（即最后一句话实现递归）和单向递归（函数中只有一个递归调用地方）都可以用循环来避免递归，更复杂的情况则要引入堆栈来进行压栈出栈来改造成非递归。

树遍历就是这么个情况，在函数中出现了两次调用，改造成非递归需要使用使用栈。先从先序遍历说起，首先肯定访问根结点（即1），然后结点1的左子树（也就是2），接着访问2的左子树（4），只有当左子树访问完了，才会访问右子树。这就是一个进栈出栈的过程。

我们可以直接使用C++标准库里的stack容器

给出借助栈，非递归实现树的前序遍历的代码

void PreOrderWithStack(BinaryTreeNode* pRoot)
{
	stack<BinaryTreeNode* >st;
	BinaryTreeNode* p=pRoot;
	while(p!=NULL||!st.empty())
	{
		while(p!=NULL)
		{
			Visit(p);                      //访问根结点
			st.push(p);                    //将结点入栈
			p=p->m_pLeft;                //遍历左子树
		}

		//遍历完了左子树以后，从最后入栈的结点开始，检查它是否有右子树
		if(!st.empty())
		{
			p=st.top();                    //出栈
			st.pop();                
			p=p->m_pRight;                //遍历右子树
		}
	}

}

中序遍历，和前序遍历的区别在于先不访问根结点，而是先遍历左子树，当遍历完了左子树以后，结点开始出栈，访问结点，遍历结点的右子树。所以，很容易的联想到，就visit(p)放在结点出栈的时候访问，也就是下面if语句里面，事实上也的确如此。

void InOrderWithStack(BinaryTreeNode* pRoot)
{
	stack<BinaryTreeNode* >st;
	BinaryTreeNode* p=pRoot;
	while(p!=NULL||!st.empty())
	{
		/*先不访问，只将结点入栈，遍历左子树 */
		while(p!=NULL)
		{
			st.push(p);           
			p=p->m_pLeft;
		}

		//遍历完左子树以后,出栈，访问结点，遍历右子树
		if(!st.empty())
		{
			p=st.top();                      //出栈
			st.pop();
			Visit(p);                       //访问结点
			p=p->m_pRight;                //遍历右子树
		}

	}
}
前序遍历或者中序遍历，有一个共同点，就是访问结点在遍历右子树的前面，所以，很容易的就可以用栈将其解决。但是后序遍历，是先遍历左子树，再遍历右子树、最后访问结点。相比前序和中序遍历要复杂一点。还是以这棵树来看，不管是1的左子树，还是1的右子树都要比根结点1先访问。当然啦，我们还是需要先遍历左子树，依次将1、2、4


压入栈中，左边遍历完成，4应该出栈了，但是还是不能访问，因为4还有右子树（8），8应该在4的前面访问。还有必须保证访问的结点，你不能再访问了。代码里有详尽的注释

void PostOrderWithStack(BinaryTreeNode* pRoot)
{
	stack<BinaryTreeNode*>st;
	BinaryTreeNode* p=pRoot;
	BinaryTreeNode*visitedNode=NULL;          //标记上一次已经访问过的结点
	while(p!=NULL||!st.empty())
	{
		if(p!=NULL)
		{
			st.push(p);                      //只入栈
			p=p->m_pLeft;                 //遍历左子树
		}
		else
		{
			p=st.top();    //得到栈顶的结点，但是不出栈哦~因为你不知道它能不能访问。

                         //如果这结点的右子树不为空，并且它的右子树没有被访问过，接着遍历右子树
			if(p->m_pRight!=NULL&&p->m_pRight!=visitedNode)
			{
				p=p->m_pRight;     //遍历右子树
				st.push(p);              //将右子树的头一个结点入栈。
				p=p->m_pLeft;       //接着遍历右子树的头一个结点的左子树
			}

			//当结点的右子树为空时(因为此时最左边一定已经遍历到底了)，或者它的右子树已经访问过了,可以出栈，访问了。
			else
			{
				p=st.top();
				st.pop();                    //出栈
				Visit(p);                    //访问
				visitedNode=p;         //将该结点标记为访问过的结点。
				p=NULL;                 //置为空值
			}
		}
	}
}

最后说一下层序遍历，遍历的顺序是1、2、3、4、5、6，也就是先访问根结点、接着依次访问1的左右孩子、然后再2的左右孩子，3的左右孩子，它不像堆栈那样后进先出，反而有点先进先出。是的，就是队列，先进先出。我们直接借助C++标准库的deque容器，它是双端队列。

void LevelOrder(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)
		return ;
	deque<BinaryTreeNode*>deq;
	deq.push_back(pRoot);                   //首先将根结点入列

	while(!deq.empty())                        
	{
		BinaryTreeNode* p=deq.front();     //出列
		deq.pop_front();
		Visit(p);                                        //访问结点
		if(p->m_pLeft!=NULL)                //当结点左孩子存在时，加入队列
			deq.push_back(p->m_pLeft);
		if(p->m_pRight!=NULL)             //当结点右孩子存在时，加入队列
			deq.push_back(p->m_pRight);
	}

}

就写到了，自己文字功底有限，有些东西讲的不是很明白，还在代码里面有比较详细的说明，现在给出完整的代码。

#include<iostream>
#include<stack>
#include<deque>
using std::stack;
using std::deque;

struct BinaryTreeNode
{
	int m_nValue;                              //结点的值
	BinaryTreeNode* m_pLeft;                  //结点的左子树
	BinaryTreeNode* m_pRight;                //结点的右子树

	//为了接下来的编程的方便，我给了一个带参数的构造函数
	BinaryTreeNode(int val)
	{
		m_nValue=val;
		m_pLeft=NULL;
		m_pRight=NULL;
	}
};
void ConnectTreeNode(BinaryTreeNode* pNode,BinaryTreeNode* pLeft,BinaryTreeNode* pRight)
{
	if(pNode==NULL)
	{
		printf("父结点为空!\n");
		return ;
	}
	pNode->m_pLeft=pLeft;
	pNode->m_pRight=pRight;
}
void Visit(BinaryTreeNode* pNode)
{
	if(pNode!=NULL)
		printf("%d\t",pNode->m_nValue);
}
void PreOrderRecursion(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)               //终止条件
		return ;

	/*
	先序遍历就是先访问根结点，
	然后访问左子树，
	最后访问右子树
	*/
	Visit(pRoot);
	PreOrderRecursion(pRoot->m_pLeft);
	PreOrderRecursion(pRoot->m_pRight);
}

void InOrderRecursion(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)               //终止条件
		return ;

	/*
	中序遍历就是先访问左子树，
	然后访问根结点，
	最后访问右子树
	*/
	InOrderRecursion(pRoot->m_pLeft);
	Visit(pRoot);	
	InOrderRecursion(pRoot->m_pRight);
}

void PostOrderRecursion(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)               //终止条件
		return ;

	/*
	后序遍历就是先访问左子树，
	然后访问右子树，
	最后访问根结点
	*/
	PostOrderRecursion(pRoot->m_pLeft);
	PostOrderRecursion(pRoot->m_pRight);
	Visit(pRoot);	
}
void PreOrderWithStack(BinaryTreeNode* pRoot)
{
	stack<BinaryTreeNode* >st;
	BinaryTreeNode* p=pRoot;
	while(p!=NULL||!st.empty())              //如果传入的是空树，根本不会进入循环
	{
		while(p!=NULL)
		{
			Visit(p);                      //访问根结点
			st.push(p);                 //将结点入栈
			p=p->m_pLeft;         //遍历左子树
		}

		//遍历完了左子树以后，从最后入栈的结点开始，检查它是否有右子树
		if(!st.empty())
		{
			p=st.top();                 //出栈
			st.pop();
			p=p->m_pRight;       //遍历右子树
		}
	}

}
void InOrderWithStack(BinaryTreeNode* pRoot)
{
	stack<BinaryTreeNode* >st;
	BinaryTreeNode* p=pRoot;
	while(p!=NULL||!st.empty())
	{
		/*先不访问，只将结点入栈，遍历左子树 */
		while(p!=NULL)
		{
			st.push(p);           
			p=p->m_pLeft;
		}

		//遍历完左子树以后,出栈，访问结点，遍历右子树
		if(!st.empty())
		{
			p=st.top();                      //出栈
			st.pop();
			Visit(p);                          //访问结点
			p=p->m_pRight;            //遍历右子树
		}

	}
}

void PostOrderWithStack(BinaryTreeNode* pRoot)
{
	stack<BinaryTreeNode*>st;
	BinaryTreeNode* p=pRoot;
	BinaryTreeNode*visitedNode=NULL;          //标记上一次已经访问过的结点
	while(p!=NULL||!st.empty())
	{
		if(p!=NULL)
		{
			st.push(p);                      //只入栈
			p=p->m_pLeft;              //遍历左子树
		}
		else
		{
			p=st.top();                       //得到栈顶的结点，但是不出栈哦~因为你不知道它能不能访问。

			//如果这结点的右子树不为空，并且它的右子树没有被访问过，接着遍历右子树
			if(p->m_pRight!=NULL&&p->m_pRight!=visitedNode)
			{
				p=p->m_pRight;     //遍历右子树
				st.push(p);              //将右子树的头一个结点入栈。
				p=p->m_pLeft;       //接着遍历右子树的头一个结点的左子树
			}

			//当结点的右子树为空时(因为此时最左边一定已经遍历到底了)，或者它的右子树已经访问过了
			//可以出栈，访问了。
			else
			{
				p=st.top();
				st.pop();                    //出栈
				Visit(p);                    //访问
				visitedNode=p;         //将该结点标记为访问过的结点。
				p=NULL;                 //置为空值
			}
		}
	}
}
void LevelOrder(BinaryTreeNode* pRoot)
{
	if(pRoot==NULL)
		return ;
	deque<BinaryTreeNode*>deq;
	deq.push_back(pRoot);                   //首先将根结点入列

	while(!deq.empty())                        
	{
		BinaryTreeNode* p=deq.front();     //出列
		deq.pop_front();
		Visit(p);                                        //访问结点
		if(p->m_pLeft!=NULL)                //当结点左孩子存在时，加入队列
			deq.push_back(p->m_pLeft);
		if(p->m_pRight!=NULL)             //当结点右孩子存在时，加入队列
			deq.push_back(p->m_pRight);
	}

}
void test()
{
	BinaryTreeNode* p1=new BinaryTreeNode(1);
	BinaryTreeNode* p2=new BinaryTreeNode(2);
	BinaryTreeNode* p3=new BinaryTreeNode(3);
	BinaryTreeNode* p4=new BinaryTreeNode(4);
	BinaryTreeNode* p5=new BinaryTreeNode(5);
	BinaryTreeNode* p6=new BinaryTreeNode(6);
	BinaryTreeNode* p7=new BinaryTreeNode(7);
	ConnectTreeNode(p1,p2,p3);
	ConnectTreeNode(p2,p4,p5);
	ConnectTreeNode(p5,p6,p7);
	//PreOrderRecursion(p1);
    //InOrderRecursion(p1);
	//PostOrderRecursion(p1);
	//PreOrderWithStack(p1);
	//InOrderWithStack(p1);
	//PostOrderWithStack(p1);
	LevelOrder(p1);
}
int main()
{
	test();
}





一文彻底搞定二叉树的前序、中序、后序遍历(图解递归非递归)
bigsai
09-22 1万+
前言 大家好，我是bigsai，在数据结构与算法中，二叉树无论是考研、笔试都是非常高频的考点内容，在二叉树中，二叉树的遍历又是非常重要的知识点，今天给大家讲讲二叉树的层序遍历。 这部分很多人可能会但是需要注重一下细节。 前面介绍了二叉排序树的构造和基本方法的实现，遍历也是比较重要的一环，并且二叉树的层序遍历也是bfs的最简单情况，这里我就将二叉树的层序遍历以及常考问题给大家分享一下。 在了解二叉树的遍历之前，需要具备数据结构与算法有队列、递归、栈、二叉树，这些内容咱们前面都有讲过，有这方面知识欠缺的同学可以
二叉树的遍历（前序，中序，后序，层序）--递归和非递归算法实现
wei.zhou的专栏
05-05 1386
二叉树的每个结点最多有两个子树（即不存在度大于2的结点），二叉树常被用作二叉查找树和二叉堆或是二叉排序树。二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度为k的二叉树至多有2^(k) -1个结点；对任何一棵二叉树T，如果其终端结点数(即叶子结点数)为n0，度为2的结点数为n2，则n0 = n2 + 1。 二叉树的链式存储结构是一类重要的数据结构，其形式定义
C#二叉树结构定义、添加节点值
weixin_41883890的博客
06-27 472
本文讲解C#二叉树结构定义、添加节点值 /// /// 二叉树的定义 /// public class BiTNode { public BiTNode() { } public int data;//数据域 public BiTNode lchild; public BiTNode rchild; } 实际main程序测试 public const int MaxSize = 50; static void Main(string[] args) { BiTNode T = new BiTNode(
小小c#算法题 - 11 - 二叉树的构造及先序遍历、中序遍历、后序遍历
weixin_33982670的博客
06-24 454
在上一篇文章 小小c#算法题-10-求树的深度中，用到了树的数据结构，树型结构是一类重要的非线性数据结构，树是以分支关系定义的层次结构，是n（n>=0)个结点的有限集。但在那篇文章中，只是简单地把结点组合到了一块。 这次，我们来简单定义一棵二叉树的数据结构，并实现其先序（根）遍历、中序（根）遍历、后序（根）遍历算法。 下面先来看一下先序遍历，中序遍历...
二叉树--实现二叉树的前序/中序/后序非递归遍历。
sayhello_world的博客
07-26 373
思路:都用到栈，用栈来存储结点//先序非递归，根左右，循环处理，先打印根再压左子树，再压右子树 void PreOrder_Nor(BinaryTreeNode<T>* pRoot) { if(pRoot == NULL) return ; stack<BinaryTreeNode<T>*> s; s.push(pRoot); while(!
C#实现二叉树的遍历
ting2909的博客
08-20 679
C#实现二叉树的前序、中序、后序遍历。 public class BinaryTreeNode { int value; BinaryTreeNode left; BinaryTreeNode right; /// <summary> /// 前序遍历 /// </summary> /// <param name="tree">&...
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
热门推荐
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
python 二叉树 前序中序后序层序 递归与非递归遍历
Mario的博客
08-06 663
Python 二叉树的遍历 二叉树初始化 # Definition for a binary tree node. class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None #示例如何初始化一个二叉树 root = node(5) root.left = node(7) root.right = node(8) root.
Python二叉树的遍历操作示例【前序遍历,中序遍历,后序遍历,层序遍历】
09-19
本文将深入探讨Python中的二叉树及其遍历方法，包括前序遍历、中序遍历、后序遍历以及层序遍历。通过具体的代码示例，我们将更好地理解这些遍历方法的工作原理和应用场景。 #### 二、二叉树基础知识回顾 二叉树是由...
二叉树的先序中序后序层序遍历C++实现
t18438605018的博客
10-18 1516
1.先上代码 #include<vector> #include <iostream> #include <queue> using namespace std; struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int a, TreeNode* l, TreeNode* r) { val = a;
二叉树的层序、前序、中序、后序遍历实现（递归与非递归的C++实现）
ladykiller21的博客
07-17 987
二叉树这种数据结构想必大家都已经非常熟悉了，他的独特的三种遍历方式也广为人知，接下来我们就来解析如何用代码实现对二叉树的遍历 首先我们录入一下二叉树结构体和后面四种遍历实现所需要的头文件 #include <iostream> #include <vector> #include <stack> #include <unordered_set>...
二叉树的遍历
用法之妙，存乎一心。
10-02 972
遍历方案 　　从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作： 　　⑴访问结点本身（N）， 　　⑵遍历该结点的左子树（L）， 　　⑶遍历该结点的右子树（R）。 　　以上三种操作有六种执行次序： 　　NLR、LNR、LRN、NRL、RNL、RLN。 　　注意： 　　前三种次
二叉树的遍历(先序，中序，后序，层序）
rzl990220的博客
08-24 496
数据结构里，我们都学过二叉树，二叉树的遍历分为先序遍历，中序遍历和后序遍历，还有相对不常用的层序遍历。 先序遍历：先遍历根再遍历左子树再遍历右子树 中序遍历：先遍历左子树再遍历根再遍历右子树 后序遍历：先遍历左子树再遍历右子树再遍历根 例如：有这么一棵树 那么这棵树的先序，中序，后序的遍历依次为 先序：ABDEC 中序：DBEAC 后序：DEBCA ...
数据结构与算法(C#实现)---二叉树
QQMagicer的专栏
04-02 1027
using System; using System.Collections;   namespace DataStructure {      ///       /// BinaryTree 的摘要说明。      ///       public class BinaryTree:NaryTree      {          //构造二叉空树          public Binary
二叉树基础及其C#代码实现
weixin_42974146的博客
04-27 1675
二叉树的遍历有深度遍历（前序、中序、后序）和广度遍历（层次遍历）。二叉树的顺序存储结构就是使用一维数组存储二叉树中的结点，并且结点的存储位置，就是数组的下标索引，如下图所示就是完全二叉树的顺序存储方式，但一般它也只适用于完全二叉树。 1.前序遍历就是从二叉树的根节点出发，当第一次到达节点时就输出节点数据，按先左后右方式访问，故上图结果为ABDHIEJCFG。 2.中序遍历就是从二叉树的根节点出发...
数据结构-二叉树-二叉树的前序、中序、后序遍历（通过递归与非递归方法实现）、层序遍历
weixin_44462294的博客
11-08 445
首先创建树类 public class tree { private Object data; private tree left; private tree right; public Object getData() { return data; } public void setData(Object data) { ...
C#二叉树学习总结1：二叉树的前、中、后、层序遍历以及二叉查找树的增删改查算法
xy_learning的博客
10-11 569
为了简化二叉查找树的删除操作，我将节点按如下定义： class Node { public int data; public Node rChild; public Node lChild; //增加父节点，目的是为了便于删出节点的操作 public Node parent; public...
二叉树先序、中序、后序、层序遍历（递归、非递归）
zhenyongyuan123的专栏
08-16 969
1、先、中、后递归遍历    其中（1）（2）（3）位置上分别表示先、中、后。 2、先、中、后非递归遍历 其中，（1）（2）（3）位置上分别表示先、中、后序遍历。 3、层序遍历
C#算法设计排序篇之11-二叉树排序（附带动画演示程序）
比特飞
08-14 1万+
二叉树排序（Binary Tree Sort） 二叉树排序是构建在二叉排序树（Binary Sort Tree）上的算法，二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值； 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； 左、右子树也分别为二叉排序树。 二叉树排序需要先生成一个二叉排序树，再使用中序遍历...
二叉树的前序中序后序层序
最新发布
04-15
前序、中序、后序和层序是四种常用的遍历方式，用于按照不同的顺序访问二叉树的节点。 1. 前序遍历（Preorder Traversal）：先访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。遍历顺序为：根-左-右。 2...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值