17、二叉树：按树状打印

最新推荐文章于 2022-07-06 10:10:48 发布
最新推荐文章于 2022-07-06 10:10:48 发布
阅读量1k 收藏
点赞数 1
分类专栏： 数据结构提高25题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014377763/article/details/117428036
版权

问题描述 :

内容：

（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。）

注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。

 

（2）基本操作20：在二叉树的二叉链表存储形式建立的基础上，设计并完成按树状打印二叉树的算法。

解题代码：

// tree.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <sstream>
#include <stack>
#include <map>
#include <ctime>
#include <array>
#include <set>
using namespace std;
vector<string> departString_string(string data)
{
	vector<int> back_part;//output type
	int i, j;
	vector<string> part;
	string A_part;
	stringstream room;
	room.str(data);
	while (room >> A_part)
		part.push_back(A_part);
	return part;
}
//————————————————
//版权声明：本文为CSDN博主「systemyff」的原创文章，遵循CC 4.0 BY - SA版权协议，转载请附上原文出处链接及本声明。
//原文链接：https ://blog.csdn.net/u014377763/article/details/113845555
template<class ElemType>
struct tree_point {
	ElemType data;//数据
	struct tree_point* l_child, * r_child;//左、右孩子指针
};
template<class ElemType>
class BinaryTree {
private:
	vector<tree_point<ElemType>*> outlist;
	tree_point<ElemType>* root;   // 头指针
public:
	BinaryTree() :root(NULL)
	{
		//无参数的构造函数
	}
	~BinaryTree()
	{
		//析构函数
	}
	void BinaryTree_fron(vector<ElemType> lis, ElemType nut)
	{
		stack<tree_point<ElemType>*> s;
		tree_point<ElemType>* p_Parent = NULL, * p_Child = NULL;
		int i = 0;
		int flag = 0;//控制左右
		p_Parent = new tree_point<ElemType>;
		p_Parent->data = lis[i];
		p_Parent->l_child = p_Parent->r_child = NULL;
		s.push(p_Parent);
		root = p_Parent;
		i = 1;
		flag = 0;
		while (!s.empty())
		{
			if (lis[i] != nut)
			{
				p_Parent = new tree_point<ElemType>;
				p_Parent->data = lis[i];
				p_Parent->l_child = p_Parent->r_child = NULL;
				if (flag == 0)
				{
					p_Child = s.top();
					p_Child->l_child = p_Parent;
				}
				else if (flag == 1)
				{
					p_Child = s.top();
					s.pop();
					p_Child->r_child = p_Parent;
				}
				s.push(p_Parent);
				flag = 0;
			}
			else
			{
				if (flag == 0)
					flag = 1;
				else if (flag == 1)
					s.pop();
			}
			i++;
		}
	}
	tree_point<ElemType>* get_root()
	{
		return root;
	}
	void s_qianxu(void)
	{
		outlist.clear();
		if (root == NULL)
			return;
		tree_point<ElemType>* p = root;
		stack<tree_point<ElemType>*> s;
		while (!s.empty() || p)
		{
			while (p)
			{
				outlist.push_back(p);
				s.push(p);
				p = p->l_child;
			}
			if (!s.empty())
			{
				p = s.top();
				s.pop();
				p = p->r_child;
			}
		}
		return;
	}
	void s_zhongxu(void)
	{
		outlist.clear();
		if (root == NULL)
			return;
		tree_point<ElemType>* p = root;
		stack<tree_point<ElemType>*> s;
		while (!s.empty() || p)
		{
			if (p)
			{
				s.push(p);
				p = p->l_child;
			}
			else
			{
				p = s.top();
				s.pop();
				outlist.push_back(p);
				p = p->r_child;
			}
		}
		return;
	}
	void s_houxu(void)
	{
		if (root == NULL)
			return;
		stack<tree_point<ElemType>*> s;
		//pCur:当前访问节点，pLastVisit:上次访问节点
		tree_point<ElemType>* pCur, * pLastVisit;
		pCur = root;
		pLastVisit = NULL;
		while (pCur)
		{
			s.push(pCur);
			pCur = pCur->l_child;
		}
		while (!s.empty())
		{
			pCur = s.top();
			s.pop();
			if (pCur->r_child == NULL || pCur->r_child == pLastVisit)
			{
				outlist.push_back(pCur);
				pLastVisit = pCur;
			}
			else
			{
				s.push(pCur);
				pCur = pCur->r_child;
				while (pCur)
				{
					s.push(pCur);
					pCur = pCur->l_child;
				}
			}
		}
		return;
	}
	void qianxu(tree_point<ElemType>* t)
	{
		outlist.push_back(t);
		if (t->l_child != NULL)
			qianxu(t->l_child);
		if (t->r_child != NULL)
			qianxu(t->r_child);
		return;
	}
	void zhongxu(tree_point<ElemType>* t)
	{
		if (t->l_child != NULL)
			zhongxu(t->l_child);
		outlist.push_back(t);
		if (t->r_child != NULL)
			zhongxu(t->r_child);
		return;
	}
	int two_n(int twoNum)
	{
		int ans = 1;
		while (twoNum--)
			ans *= 2;
		return ans;
	}
	void houxu(tree_point<ElemType>* t)
	{
		if (t->l_child != NULL)
			houxu(t->l_child);
		if (t->r_child != NULL)
			houxu(t->r_child);
		outlist.push_back(t);
		return;
	}
	int c_t = 0;
	int full_floorTree = 0;
	void cengxu(tree_point<ElemType>* t)
	{
		vector<tree_point<ElemType>* > q;
		q.push_back(t);
		int last = 1, cur = 0,ceng_num;
		while (cur < q.size())
		{
			ceng_num = 0;
			last = q.size();
			while (cur < last)
			{
				outlist.push_back(q[cur]);
				if (q[cur]->l_child)
					q.push_back(q[cur]->l_child);
				if (q[cur]->r_child)
					q.push_back(q[cur]->r_child);
				++cur;
				ceng_num++;
			}
			c_t++;
			if (ceng_num != two_n(c_t-1))
			{
				full_floorTree ++;
			}

		}
	}
	bool floorCheck_full()
	{
		if (!root) 
			return 0;
		queue<tree_point<ElemType>* > Q;
		tree_point<ElemType>* p;
		p = root;
		Q.push(p);
		while (!Q.empty())
		{
			p = Q.front();
			Q.pop();
			if (p==NULL) 
				break;
			Q.push(p->l_child);
			Q.push(p->r_child);
		}
		while (!Q.empty()) 
		{
			p = Q.front();
			Q.pop();
			if (p) 
				return false;
		}
		return true;
	}
	void out_lis()
	{
		int i;
		for (i = 0; i < outlist.size(); i++)
		{
			cout << outlist[i]->data;
			if (i != outlist.size() - 1)
				cout << ",";
			else
				cout << endl;
		}
		outlist.clear();
	}
	int cnt = 0, p_cnt = 0;
	void t_cnt(tree_point<ElemType>* t)
	{
		p_cnt++;
		if (t->l_child != NULL && t->r_child != NULL)
			cnt++;
		if (t->l_child != NULL)
			t_cnt(t->l_child);
		if (t->r_child != NULL)
			t_cnt(t->r_child);
	}
	int cengshu()
	{
		c_t = 0;
		cengxu(root);
		outlist.clear();
		return c_t;
	}
	int P_cengshu(tree_point<ElemType>* t)
	{
		c_t = 0;
		cengxu(t);
		outlist.clear();
		return c_t;
	}
	int twocnt()
	{
		cnt = 0;
		t_cnt(root);
		return cnt;
	}
	int P_twocnt(tree_point<ElemType>* t)
	{
		cnt = 0;
		t_cnt(t);
		return cnt;
	}
	int pointcnt()
	{
		p_cnt = 0;
		t_cnt(root);
		return p_cnt;
	}
	tree_point<ElemType>* father_p;
	void find_fatherNow(tree_point<ElemType>* t, ElemType ss)
	{
		if (t->l_child != NULL)
			if (t->l_child->data == ss)
			{
				father_p = t;
				return;
			}
		if (t->r_child != NULL)
			if (t->r_child->data == ss)
			{
				father_p = t;
				return;
			}
		if (t->l_child != NULL)
			find_fatherNow(t->l_child, ss);
		if (t->r_child != NULL)
			find_fatherNow(t->r_child, ss);
		return;
	}
	tree_point<ElemType>* find_father(tree_point<ElemType>* t, ElemType ss)
	{
		father_p = NULL;
		find_fatherNow(t, ss);
		return father_p;
	}
	tree_point<ElemType>* nas_p;
	void find_selfNOW(tree_point<ElemType>* t, ElemType ss)
	{
		if (t->data == ss)
			nas_p = t;
		if (t->l_child != NULL)
			find_selfNOW(t->l_child, ss);
		if (t->r_child != NULL)
			find_selfNOW(t->r_child, ss);
		return;
	}
	tree_point<ElemType>* find_self(tree_point<ElemType>* t, ElemType ss)
	{
		nas_p = NULL;
		find_selfNOW(t, ss);
		return nas_p;
	}
	void fast_delChild(tree_point<ElemType>* t, bool flag)
	{
		if (flag == 0)
			t->l_child = NULL;
		else
			t->r_child = NULL;
		return;
	}
	void slow_delChild(tree_point<ElemType>* t, bool flag)
	{
		if (flag == 0)
			t->l_child = NULL;
		else
			t->r_child = NULL;
		return;
	}
	bool is_same = 1;
	bool check_same(tree_point<ElemType>* t1, tree_point<ElemType>* t2)
	{
		if (((t1->l_child != NULL && t2->l_child != NULL) || (t1->l_child == NULL && t2->l_child == NULL))
			&& ((t1->r_child != NULL && t2->r_child != NULL) || (t1->r_child == NULL && t2->r_child == NULL))
			&& t1->data == t2->data)
		{
			if (t1->l_child != NULL)
				check_same(t1->l_child,t2->l_child);
			if (t1->r_child != NULL)
				check_same(t1->r_child, t2->r_child);
		}
		else
		{
			is_same = 0;
			return 0;
		}

	}
	bool operator==(BinaryTree B2)
	{
		is_same = 1;
		check_same(root, B2.get_root());
		return is_same;
	}
	vector<ElemType> path_note;
	void find_path_DFS(tree_point<ElemType>* t, ElemType num)//递归寻找元素节点
	{
		path_note.push_back(t->data);
		if (t->data == num)
		{
			int i;
			for (i = 0; i < path_note.size()-1; i++)
				cout << path_note[i] << "->";
			cout << path_note[i] << endl;
		}
		if (t->l_child != NULL)
			find_path_DFS(t->l_child, num);
		if (t->r_child != NULL)
			find_path_DFS(t->r_child, num);
		path_note.erase(path_note.end() - 1);
	}
	void find_path(ElemType elemt)
	{
		find_path_DFS(root, elemt);
		return;
	}
	tree_point<ElemType>* find_sameFather_DFS(tree_point<ElemType>* t, tree_point<ElemType>*p, tree_point<ElemType>*q)
	{
		if (t == NULL) 
			return NULL; // 如果树为空，直接返回null
		if (t == p || t == q) 
			return t; // 如果 p和q中有等于 root的，那么它们的最近公共祖先即为root
		// 左子树和右子树 
		tree_point<ElemType>* N_left = find_sameFather_DFS(t->l_child, p, q); 
		// 遍历左子树，找到了p或q，则先返回 
		tree_point<ElemType>* N_right = find_sameFather_DFS(t->r_child, p, q); 
		// 遍历右子树，找到了p或q，则先返回 
		if (N_left == NULL) 
			return N_right; 
		// p和 q都找不到，则 p和 q一定都在右子树中，先遍历到的那个就是最近公共祖先（一个节点也可以是它自己的祖先）
		else if (N_right == NULL) 
			return N_left; 
		// 如果 l不为空，在左子树中有找到节点（p或q），这时候要再判断一下右子树中的情况，如果在右子树中，p和q都找不到，则 p和q一定都在左子树中
		else return t; 
		//当 l和 r均不为空时，说明 p、q节点分别在 root异侧, 最近公共祖先即为 root
	} 
	tree_point<ElemType>* find_sameFather(ElemType pas_a, ElemType pas_b)
	{
		tree_point<string>* ans, * tp1, * tp2;
		tp1 = find_self(root, pas_a);
		tp2 = find_self(root, pas_b);
		if (tp1 == root || tp2 == root)
			return NULL;
		ans = find_sameFather_DFS(root, tp1, tp2);
		if (ans == tp1)
		{
			ans = find_father(root, ans->data);
		}
		if (ans == tp2)
		{
			ans = find_father(root, ans->data);
		}
		return ans;
	}
	void Print_BinaryTree(tree_point<ElemType>* t, int i)
	{
		if (!t) 
			return;
		if (t->r_child) 
			Print_BinaryTree(t->r_child, i + 1);
		for (int j = 1; j <= i; j++) 
			cout << "  ";
		cout << t->data << " " << endl;
		if (t->l_child) 
			Print_BinaryTree(t->l_child, i + 1);
	}
	bool Print_Tree() 
	{
		int layer = 0;
		if (root == NULL)  
			return false;
		Print_BinaryTree(root, layer);
	}
}; 

int main()
{
	string s, ins, ins1, nulls;
	vector<string> part_in, part_in1;
	BinaryTree<string> a;
	/*BinaryTree<string> b;*/
	cin >> nulls;
	cin.get();
	getline(cin, ins);
	part_in = departString_string(ins);
	a.BinaryTree_fron(part_in, nulls);
	a.Print_Tree();
	return 0;
}

 

systemyff
关注
专栏目录
[二叉树] 按树形状打印二叉树（严蔚敏《数据结构》6.69）
geodoer
10-04 6910
题目来源：严蔚敏《数据结构》C语言版本习题册 6.69 【题目】6.69 假设以二叉链表存储的二叉树中，每个结点所含数据元素均为单字母，试编写算法，按树形状打印二叉树的算法。例如：左下二叉树印为右下形状。 【思路】 观察例子–&amp;gt;打印的顺序为：CFEADB 顺序肯定与递归顺序有关–&amp;gt;写出三种递归序列 - 先序：ABDCEF - 中序：FCEADB–&amp;gt;逆序即是打印的顺序 前面...
打印树形图（二叉树）
weixin_45157679的博客
09-04 7125
控制台打印树形图（二叉树） 在读leetcode第337题时，发现题目中的二叉树排列的很规整、漂亮，如下： 示例一： 输入: [3,2,3,null,3,null,1] 3 / \ 2 3 \ \ 3 1 输出: 7 示例二： 输入: [3,4,5,1,3,null,1] 3 / \ 4 5 / \ \ 1 3 1 输出: 9 于是参考了博客，并把格式加以修改，最后在Vs 2019 中打印得到
按照树形结构直观地打印出一棵二叉树(Java)
04-28 3937
平时无论是工作还是学习中，在写代码时，树总是一个非常常见的数据结构。在我们完成一棵树的构建之后，如果我们想要看这棵树的结构...
15、二叉树：距离最近的共同祖先
windyuan~
05-31 679
问题描述 : 目的：使用C++模板设计二叉树的抽象数据类型（ADT）。并在此基础上，使用二叉树ADT的基本操作，设计并实现简单应用的算法设计。 内容：（1）请参照链表的ADT模板，设计二叉树的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）AD.
二叉树：距离最近的共同祖先
Blackoutdragon的博客
12-07 792
文章目录问题描述 :输入说明 :输出说明 :输入范例 :输出范例 :思路分析实现伪码事故现场第一次提交分析总结如果不妥，请在评论区留言，或者加我的扣扣一起讨论学习，651378276 问题描述 : 目的：使用C++模板设计二叉树的抽象数据类型（ADT）。并在此基础上，使用二叉树ADT的基本操作，设计并实现简单应用的算法设计。 内容：（1）请参照链表的ADT模板，设计二叉树的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分
LeetCode - 236. 二叉树的最近公共祖先（树的遍历）
your_棒棒糖的博客
11-18 286
二叉树的最近公共祖先 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解.
二叉树最近共同祖先问题
weixin_30426879的博客
09-20 123
最近共同祖先问题 Union/Find 数据结构的一个例子是离线的最近共同祖先（NCA）问题。 给定一棵树和树中节点对的列表，对每一个节点对需找到其最近的共同祖先。 图中显示了一棵树，其带有一个含5个请求的对偶列表。对于节点对u和z，节点C是最近的共同祖先（思考 A和B是否满足条件？）。该问题...
按树状输出二叉树
12-18
二叉树是一种特殊的树形结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。在计算机科学中，二叉树广泛应用于算法设计、数据存储和检索等领域。二叉树具有以下特点： - **节点**：二叉树中的每个...
C语言树状打印二叉树
niyilu45的博客
06-29 2398
占坑以后改
树状显示二叉树（标准C语言实现）
热门推荐
weixin_40568729的博客
02-28 1万+
二叉搜索树的黑框树状显示（标准C语言实现） 最近在用C语言实现平衡二叉搜索树，用了半天时间实现了树的基本功能后，发现我的二叉树打印方法还是停留在简单的逐行打印，此时的效果图如下： 一行的每两个数值分别对应上一行一个数值的左右孩子，用星号表示空。无疑这中表示方法十分鸡肋，利用人工点数的方式确定节点的左右孩子，实在不方便调试和扩展功能，如果节点多了可能还会造成开发者白内障，危害极大。 出于开发效率和...
按二叉树的形状打印二叉树
12-10
typedef struct Node//定义一个二叉树结点的结构体 { char data; //每个结点的数值 int num; //数没个结点的编号 struct Node * LChild; struct Node * RChild; }BiTNode,* BiTree; int a=0; void CreateBiTree(BiTree * bt)//创建一个二叉树 { char ch; ch=getchar(); //逐个的为结点赋值 if(ch==' ') * bt=NULL; else { * bt=(BiTree)malloc(sizeof(BiTNode)); (* bt)->data=ch; CreateBiTree(&((* bt)->LChild));//遍历左子树 CreateBiTree(&((* bt)->RChild));//遍历右子树 } } void posttree(BiTNode *bt) //通过后序遍历，给元素进行编号 { if(bt!=NULL) { bt->num=++a; //通过全局变量，给结点元素编号 posttree(bt->LChild); //遍历右子树 posttree(bt->RChild); //遍历左子树 } } /*按数的形状打印竖向二插树*/ void PrintTree(BiTNode *bt,int nLayer) { if(bt==NULL) return; PrintTree(bt->RChild, nLayer+4); for(int i=0;inum,bt->data);/*按逆中序输出结点，用程次决定左右位置*/ PrintTree(bt->LChild, nLayer+4); } void main() { BiTree bt; int i=0,nLayer=0; printf("\n你好："); printf("\n请输入一个字符串，以空格作为空字符：\n"); CreateBiTree(&bt); posttree(bt); printf("按树状打印的二叉树的结点和编号为：\n"); printf("\n\n"); PrintTree(bt,nLayer); printf("\n\n^_^ ^_^ ^_^ 谢谢使用，再见！^_^ ^_^ ^_^\n\n\n"); }
二叉树转化为中缀表达式
vimpirespider的博客
04-15 1478
void BtreeToExp(Tree T,int deep) { if(T==NULL){ return ; } else if(T->left==NULL&&T->right==NULL){ printf("%d",T->data); } else{ if(deep>1) cout<<"("; BtreeToExp(T->left,deep+1); printf("%d",T->data); Btree.
[二叉树]leetcode236：二叉树的最近共同祖先(medium)
algsup
08-21 421
题目： 解题思路： 说实话被这题困了好久了，代码是参考评论区的，递归代码没读懂啥意思。后来慢慢明白了一点吧，这个递归就类似于走迷宫问题，要注意回溯。留个坑吧，以后在解答具体递归过程。 class Solution { public: TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) { ...
二叉树（十五）：二叉树的最近公共祖先
qq_42138662的博客
06-21 568
一、二叉树的最近公共祖先 二叉树的最近公共祖先 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 1、解题思路 要想解决公共祖先问题，就要从下向上查找，因此我们要使用后序遍历来遍历二叉树。 递归三要素： 递归函数返回值及参数 需要递归函数返回值，来告诉我们是否找到节点q或者p，那么返回值为bool类型就
算法_二叉树_二叉树的最近公共祖先
一个努力生活的人的博客
12-21 581
文章目录二叉树的最近公共祖先1.两种解法递归法--后序遍历迭代法--层序遍历2.总结算法 二叉树的最近公共祖先 leetcode链接 1.两种解法 递归法–后序遍历 思路：这道题想求两个节点的最近公共祖先，所以我们要从下往上遍历这棵树，并且要先判断两个孩子，然后再去判断根节点的逻辑，所以我们想到使用后序遍历。 对每个节点而言，如果它的左子树中有p（或q），它的右子树中有q（或p），那么当前节点就是他们的最近公共祖先。 所以我们定义单层节点操作逻辑： 1.如果当前节点为空，则返回None 2.如果当前节点为
二叉（搜索）树的最近公共祖先 ●●
chenyfan_blog
07-06 974
二叉（搜索）树的最近公共祖先 ●●、树的遍历
二叉树最近公共祖先
Futureing的博客
06-24 2545
递归与非递归方式实现二叉树最近公共祖先
按树状打印二叉树
Fishermanykx的博客
11-13 5566
程序说明 一、输入输出说明 输入：该程序输入分两行，第一行为对这棵二叉树(记为BinaryTree)进行前序遍历所得的序列，第二行为对BinaryTree进行中序遍历所得的序列。结点元素之间均用空格隔开。 Sample Input A B D C E F B D A E F C 输出：该程序输出按树状打印的BinaryTree Sample Output ...
二叉树的最近公共祖先
longool的博客
06-13 302
二叉树的最近公共祖先 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。” 例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4] 示例 1: 输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1 输出: 3 解释:
二叉树数据结构实现：树状垂直打印
在本次课程设计中，主要目标是实现一个名为`displaytree`的函数，该函数用于以垂直打印的方式显示二叉树的直观示意图，确保同一层的节点在同一行上。设计中考虑了数据宽度（datawidth）和屏幕宽度（screenwidth）对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值