C++数据结构与算法 --二叉树

最新推荐文章于 2022-08-14 15:58:17 发布
最新推荐文章于 2022-08-14 15:58:17 发布
阅读量947 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bossDDYY/article/details/122784276
版权

二叉树

（本博客主要是用法，对于二叉树的实现没有过多的讲解好像）
菜鸡一枚，不喜勿喷！~~~~
结点结构

struct Tree
{
  int val;
    Tree *left;
    Tree *right;
};

遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hk7PFq1d-1643965048440)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220203141700136.png)]

  • 先序遍历

    • //递归遍历
void preorderTraversal(Tree* head)
{
    if(head == nullptr)return;
    cout<<head->val<<endl;
    preorderTraversal(tree->left);
    preorderTraversal(tree->right);
}
//非递归遍历
void preorderTraversal(Tree* head)
{
    stack<Tree*>s;
    s.push(head);
    while(!s.empty())
    {
        head = s.top();
        s.pop();
        cout<<head->val<<" ";
        if(head->right)
            s.push(head->right);
        if(head->left)  
            s.push(head->left);
    }
}

  • 中序遍历

    • //递归遍历
void inOrderUnRecur(Tree* head)
{
    if(head == nullptr)return;
    inOrderUnRecur(tree->left);
     cout<<head->val<<endl;
    inOrderUnRecur(tree->right);
}
//非递归遍历
void inOrderUnRecur(Tree* head)
{
	stack<Tree*>s;
	while (head!=nullptr||!s.empty())
	{
        //左边界进栈
		if (head)
		{
			s.push(head);
			head = head->left;
		}
        //弹出节点，到右数 重复过程
		else
		{
			head = s.top();
			s.pop();
			cout << head->val << " ";
			head = head->right;
		}
	}
}

  • 后序遍历

    • //递归遍历
void postorderTraversal(Tree* head)
{
    if(head == nullptr)return;
    postorderTraversal(tree->left);
    postorderTraversal(tree->right);
    cout<<tree->val<<endl;
}
//非递归遍历
void postorderTraversal(Tree* head)
{
    stack<Tree*>s;
    stack<Tree*>collection;
    s.push(head);
    while(!s.empty())
    {
        head = s.top();
        collection.push(head);
        s.pop();
        if(head->left)  
            s.push(head->left);
        if(head->right)
            s.push(head->right);
    }
    while(!collection.empty())
    {
        cout<<collection.top()<<" ";
        collection.pop();
    }
}

深度优先遍历 == 先序遍历

  • 宽度优先遍历

    • 用 队列 先放头节点，出队列打印，先放左后放右

    • void widthTraversal(Tree* head)
{
	if (head == nullptr)return;
	queue<Tree*>q;
	q.push(head);
	while (!q.empty())
	{
		head = q.front();
		q.pop();
		cout << head->val << " ";
		if (head->left)
		{
			q.push(head->left);
		}
		if (head->right)
		{
			q.push(head->right);
		}
	}
}

//层序遍历
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector <vector <int>> ret;
        if (!root) {
            return ret;
        }

        queue <TreeNode*> q;
        q.push(root);
        //每次队列从有到无代表着一层
        while (!q.empty()) {
            //获取该层的元素个数
            int currentLevelSize = q.size();
            ret.push_back(vector <int> ());
            for (int i = 1; i <= currentLevelSize; ++i) {
                auto node = q.front(); q.pop();
                ret.back().push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
        }
        
        return ret;
    }
};

树的最大宽度

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CPhTnbs9-1643965048442)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220203163946359.png)]

//在深度优先遍历上更改
//使用哈希表
int maxTreeWidth(Tree* head)
{
	if (head == nullptr)return 0;
	queue<Tree*>q;
	unordered_map<Tree*, int>levelMap;
    //当前的层数      当前层数结点的个数    最大宽度
	int curLevel = 1, curLevelNodes = 0, maxNum = -1;
	levelMap.insert(make_pair(head, curLevel));
	q.push(head);
	while (!q.empty())
	{
		head = q.front();
		q.pop();
        //根据树的结点找到当前结点的层数
		unordered_map<Tree*,int>::iterator curNodeLevel = levelMap.find(head);
		if (curNodeLevel->second == curLevel)
			curLevelNodes++;
		else
		{
			maxNum = max(maxNum, curLevelNodes);
			++curLevel;
			curLevelNodes = 1;
		}
		if (head->left)
		{
			levelMap.insert(make_pair(head->left, (curNodeLevel->second) + 1));
			q.push(head->left);
		}
		if (head->right)
		{
			levelMap.insert(make_pair(head->right, (curNodeLevel->second) + 1));
			q.push(head->right);
		}
	}
	return max(maxNum, curLevelNodes);
}


//不使用哈希表  有限几个变量
int maxTreeWidthNoHash(Tree* head)
{
	if (head == nullptr)return 0;
	queue<Tree*>q;
	q.push(head);
	Tree* levelEnd = head, * nextEnd = head;
	int num = 1, maxNum = -1;
	while (!q.empty())
	{
		head = q.front();
		q.pop();
		if (head->left)
		{
			q.push(head->left);
			nextEnd = head->left;
		}
		if (head->right)
		{
			q.push(head->right);
			nextEnd = head->right;
		}
		if (head == levelEnd)
		{
			maxNum = max(maxNum, num);
			num = 1;
			levelEnd = nextEnd;
			nextEnd = nullptr;
		}
		else
		{
			num++;
		}
	}
	return maxNum;
}

class Solution {
public:
	int levelOrder(Tree* root) {
		int ret = 0;
		if (!root) {
			return ret;
		}

		queue <Tree*> q;
		q.push(root);
		//每次队列从有到无代表着一层
		while (!q.empty()) {
			//获取该层的元素个数
			int currentLevelSize = q.size();
			ret = max(ret, currentLevelSize);
            //循环的目的就是清空每一层的节点
			for (int i = 1; i <= currentLevelSize; ++i) {
				auto node = q.front(); q.pop();
				if (node->left) q.push(node->left);
				if (node->right) q.push(node->right);
			}
		}

		return ret;
	}
};

搜索二叉树 BST

左边小 中间在其中 右边大

右边>中间>左边

判断是否为BST：可以中序遍历进行判断

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AQoF4PkC-1643965048443)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220203212450438.png)]

//递归实现
bool isBST(Tree* head)
{
	if (!head)return false;
	//判断左树是否为搜索二叉树
	bool leftIsBST = isBST(head->left);
	int preValue = INT32_MIN;
	//左边的BST
	if (leftIsBST)
	{
		//将上次的值改为当前结点的值
		preValue = head->val;
	}
	else
	{
		return false;
	}
	//走到这说明左树是BST，直接返回右数是否为BST
	return isBST(head->right);
}

//非递归实现
bool isBSTNoRecursion(Tree* head)
{
	stack<Tree*>s;
	int preValue = INT32_MIN;
	while (!s.empty()||head!=nullptr)
	{
		if (head)
		{
			s.push(head);
			head = head->left;
		}
		else
		{
			head = s.top();
			s.pop();
			if (preValue>=head->val)
				return false;
			else
				preValue = head->val;
			head = head->right;
		}
	}
	return true;
}
//黑盒实现 这种情况默认子树给整棵树所有想要的信息   二叉树递归套路
struct returnData
{
	int max;
	int min;
    //是否为搜索二叉树
	bool isBST;
    //代表树是否村子啊
	bool isFlag;
	returnData(bool is, int mi, int ma,bool f) :max(ma), min(mi), isBST(is), isFlag(f) {}
};
returnData process(Tree* head)
{
	if (head==nullptr)
	{
		return returnData(true,INT32_MIN,INT32_MAX,false);
	}
	//获取左树的信息
	returnData left = process(head->left);
	//获取右树的信息
	returnData right = process(head->right);

	//整棵树的信息
	bool isBST = true;
	int min_X = head->val;
	int max_X = head->val;
	if (left.isFlag)
	{
		min_X = min(min_X, left.min);
		max_X = max(max_X, left.max);
	}
	if (right.isFlag)
	{
		min_X = min(min_X, right.min);
		max_X = max(max_X, right.max);
	}
	if (left.isFlag&&(!left.isBST || left.max>=head->val))
	{
		isBST = false;
	}
	if (right.isFlag && (!right.isBST || right.min <= head->val))
	{
		isBST = false;
	}
	return returnData(isBST, min_X, max_X,true);
}

完全二叉树 CBT

怎么判断？按照宽度遍历

条件

  • 任一节点，有右节点无左节点 == 返回false
  • 在条件一成立的条件下，如果遇到第一个左右不全的节点，后续的节点都得是叶节点（不能有子节点）
bool isCBT(Tree* head)
{
	queue<Tree*>q;
	q.push(head);
	//是否遇到了第一个左右不全的节点
	bool flag = false;
	while (!q.empty())
	{
		head = q.front();
		q.pop();
		if (
			//左空 右不空
			(head->left== nullptr &&head->right!=nullptr)
			||
            //遇到第一个左右不全的节点，后续的节点有的不是叶节点
			(flag&&(head->left != nullptr || head->right != nullptr))
			)
		{
			return false;
		} 
		if (head->left)
			q.push(head->left);
		if (head->right)
			q.push(head->right);
		if (head->left == nullptr || head->right == nullptr)
		{
			flag = true;
		}
	}
	return true;
}

满二叉树

节点个数(N)和最大深度(L)满足：N = 2^L - 1

//满二叉树
class manBinaryTree
{
private:
	struct returnData
	{
		int nodes;
		int height;
		returnData(int n, int h) :nodes(n), height(h) {}
	};
	returnData process(Tree* &head)
	{
		if (head == nullptr)
		{
			return returnData(0, 0);
		}
		returnData left = process(head->left);
		returnData right = process(head->right);

		int height = max(left.height, right.height) + 1;
		int nodes = left.nodes + right.nodes + 1;
		return returnData(nodes, height);
	}
public:
	bool isMBT(Tree*& head)
	{
		returnData data = process(head);
		cout << "nodes" << data.nodes << " " << "height:" << data.height << endl;
		//1 << data.height代表 1右移data.height位 就是2的data.height次方
		return data.nodes == ( (1 << data.height) - 1);
	}
};

平衡二叉树

任一一颗子树，左树的高度和右树的高度差都不能大于一

  • 左子树是平衡二叉树
  • 右子树是平衡二叉树
  • |左子树高度 - 右子树高度|<=1

在这里插入图片描述

//代码黑盒   二叉树递归套路
class balanceBinaryTree
{
public:
	struct returnData
	{
		bool isBBT;
        //树的高度
		int height;
		returnData(bool bbt, int h) :isBBT(bbt), height(h) {}
	};
	returnData process(Tree* head)
	{
		if (head == nullptr)
		{
			return returnData(true, 0);
		}
		returnData left = process(head->left);
		returnData right = process(head->right);
		//整棵树的信息
        //此处会计算树的高度
		int height = max(left.height, right.height) + 1;
		bool isBBT = true;
		if (!left.isBBT||!right.isBBT||abs(left.height - right.height)>1)
			isBBT = false;
		return returnData(isBBT, height);
	}
};

二叉树递归套路

树型DP

给定一棵树，认为左右子树可以给自己所有想要的信息

实用

最低公共祖先

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GzzeA4LD-1643965048446)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220204130443355.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AOwIBpCg-1643965048447)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220204130616896.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gjQkrwUK-1643965048448)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220204135351424.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v2vPod2C-1643965048449)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220204135356827.png)]

//使用哈希表实现


//套路的实现  具体看上图
class LowestAncestor 
{
public:
	Tree* lowerAncestorFun(Tree* head, Tree* o1, Tree * o2)
	{
		return process(head, o1, o2);
	}
private:
	Tree* process(Tree* head, Tree* o1, Tree* o2)
	{
		if (head == nullptr||head==o1||head==o2)
			return head;
		Tree* left = process(head->left,o1,o2);
		Tree* right = process(head->right, o1, o2);
		//左边右边都不为空的话  代表该head为公共祖先
		if (left!=nullptr&&right!=nullptr)
			return head;
		//代表左右两个节点全null返回null  一个不为空返回不为空的哪一个
		return (left != nullptr) ? left : right;
	}
};

后继节点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NbTJtzuU-1643965048449)(C:\Users\26737\AppData\Roaming\Typora\typora-user-images\image-20220204152643460.png)]

一种情况没有父指针：时间复杂度O(N)

如果两个节点距离相差为k：时间复杂度O(K)

struct  TreeP
{
	int val;
	TreeP* left;
	TreeP* right;
	TreeP* parent;
	TreeP() : val(0), left(nullptr), right(nullptr),parent(nullptr) {}
	TreeP(int x) : val(x), left(nullptr), right(nullptr), parent(nullptr) {}
	TreeP(int x, TreeP* left, TreeP* right, TreeP* parent) : val(x), left(left), right(right), parent(parent) {}
};
//后继节点
class FindBackList 
{
public:
	TreeP* findBackList(TreeP* curList)
	{
		if (curList == nullptr)
			return nullptr;
		//有右树
		if (curList->right)
			return findLeft(curList->right);
		//无右树
		else
		{
			TreeP* parent = curList->parent;
			while (parent!=nullptr&& curList != parent->left)
			{
				curList = parent;
				parent = curList->parent;
			}
			return parent;
		}
	}
private:
	TreeP* findLeft(TreeP* head)
	{
		while (head->left)
			head = head->left;
		return head;
	}
};

序列化和反序列化

在这里插入图片描述
在这里插入图片描述

//序列化和反序列化
class TreeBeString
{
public:
	string treeBeString(Tree* head)
	{
		if (head == nullptr)return "#_";
		
		string res =to_string(head->val)+ "_";
		res+=treeBeString(head->left);
		res+=treeBeString(head->right);
		return res;
	}
	Tree* stringBeTree(string s)
	{
		int pos = -1,index = 1;
		int len = s.size();
		queue<string>ch;
		//6_5_4_#_#_6_#_#_9_8_#_#_10_#_#_
		while (pos<len-1)
		{
			string str = s.substr(pos+1, index-pos-1);//开始位置  开始个数
			pos = s.find('_', pos+1);
			index = s.find('_', index + 1);
			ch.push(str);
		}
		return reconByPreString(ch);
		
	}
	Tree* reconByPreString(queue<string>s)
	{
		string value = s.front();
		s.pop();
		if (value == "#")
			return nullptr;
		//aoti将char 或者 char[]转化为int
		Tree* head = new Tree(atoi(value.c_str()));
		head->left = reconByPreString(s);
		head->right = reconByPreString(s);
		return head;
	}
};

纸条折痕问题

在这里插入图片描述

//纸条遍历
class T
{
public:
	void printAllFolds(int N)
	{
		//false代表 凹   true代表凸
		process(1, N, false);
	}
private:
	void process(int i, int N, bool down)
	{
	//相当于模拟中序遍历二叉树  并不实际存在的二叉树
		//i代表当前层数
		if (i > N)return;
		process(i + 1, N, false);
		cout <<(down ? "凸" : "凹");
		process(i + 1, N, true);
	}
};
yb0os1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中序遍历BST的算法及实现
愿君出走半生，归来时仍是少年
07-15 915
问题描述：在二叉树中，一个节点的后续是在中序遍历过程中，在它之后访问的下一个节点，如果某节点是中序遍历的最后一个节点，那么它的后续为 NULL。 在 BST 中，给定节点的后续节点就是大于该节点的最小结点，这个性质对于查找比某元素大的下一个元素时非常有用。 如上图，8 的后续是 10，10 的后续是 12，14 的后续是 20。 现给定一个节点，请设计算法查找中序遍历中，该节点的后续节点。 解法一：使用双亲指针 这种解法需要每个节点都有指向双亲的指针，算法可分成两种情况来处理： （1）.
BST算法原理及其实现
sunjunior的专栏
04-28 2791
首先，我们先了解下递归。说到递归，数据结构中树介绍章节中有大量的实例用了，包括二叉树定义与遍历等。当然一般公司项目中很少用它，主要是效率低下，同时递归涉及到函数反复建栈，压栈，销毁栈的过程，开销较大。这里仅仅作为一种技术探讨来研究。递归，简单地说就是函数自己调用自己，网上也有不少解释了。这里我的看法是将整个递归过程看做一种函数映射关系，即 F(A) --> B,如果B与A具有相同的属性和操作，同时
链表基础【C++实现】
weixin_41930950的博客
08-14 3366
链表的定义以及基本操作
BST算法分析
sinat_30035833的博客
03-05 1625
关于BST树的一些基本概念上一篇博客已经说过了，今天对bst树做了增，查、删以及查找最小值的操作，使用java代码实现。从代码中对这个bst有了更深的理解。 bst概念重申一下 来自百度百科：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树...
BST算法
01-25
二叉排序树,shujujiegou
数据结构与算法实验（C++）：二叉树实验-代码
01-18
1.内容概要： （1）实验目的： 1）熟练掌握二叉链的存储特点； 2）熟练掌握二叉树的基本操作； 3）熟练掌握基于二叉链的二叉树操作算法实现； 4）能灵活使用二叉树解决具体的问题。...数据结构与算法实验
数据结构与算法-二叉树的创建与操作
04-21
在IT领域，数据结构与算法是编程基础的重要组成部分，尤其对于C++开发者来说更是如此。本主题聚焦于“二叉树的创建与操作”，这是一种特殊的数据结构，它以树的形式存储数据，每个节点最多有两个子节点，通常称为左...
C++数据结构与算法 （第4版）
01-06
根据提供的文件信息，这里主要关注的是“C++数据结构与算法（第4版）”这一主题，虽然实际内容并未给出具体章节或知识点，但我们可以基于标题、描述以及部分已知内容来推测书中可能涵盖的关键知识点。 ### C++数据...
数据结构C++版-二叉树实验-使用类模板的方式实现
11-27
一、实验目的：1、实现二叉树的存储结构（二叉链表或三叉...自行实现二叉树的存储结构与相关操作，不得使用STL(标准模板库)现成代码；3.二叉树结点的数据类型自行定义；4.编程语言：C++5.使用类模板完成二叉树的定义
C/C++，树算法-二叉树（BTree）的基本数据结构
最新发布
05-14
C/C++，树算法——二叉树（BTree）的基本数据结构
C++合并两个有序的单链表
Top5软件工程硕士，先后在京东、字节从事多年Java后端开发、实时和离线大数据开发
08-25 4411
一直看到的都是合并的函数，却没有看到完整的输入输出啥样的，今天自己写一个，包含链表的初始化 // 合并两个有序链表.cpp : 定义控制台应用程序的入口点。 #include "stdafx.h" #include using namespace std; struct ListNode{ int val; ListNode* next; }; ListNode* initList1
BST的概念，以及查找，插入，删除算法
zhengxu_Lee的博客
03-11 8044
BST的概念BST，又叫平衡二叉树，是一种循关键码访问的二叉树，并且要求保持顺序性，即任一节点不小于其左后代，不大于其右后代（注意是后代，不是孩子）。BST的顺序性使得其中序遍历序列一定是单调非降的。BST的查找算法BinNodePos(T) BST_Search1(BinNodePos(T)&amp;v,const T&amp; e,BinNodePos(T)hot) {     if(v==n...
LintCode 删除链表中等于给定值val的所有节点
Ryan的博客
03-23 3679
给出链表 1->2->3->3->4->5->3, 和 val = 3, 你需要返回删除3之后的链表：1->2->4->5。 C++语言 递归形式：每次对头进行判断是否此值等于给定值val，如果相等则将此节点删除，将下一个节点作为头节点递归调用自己，否则将此节点的下一个节点为作为头节点递归调用自己，调用后的返回值作为此时头节点的下一个节点。 /*  * Definition
链表反转（C++力扣）
weixin_45479946的博客
08-21 504
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] 第一种方法，直接反转 class Solution { public: vector<int>m; vector<int> reversePrint(ListNode* head) { while(head) { m.push_back(head->val);
查找算法系列之复杂算法：二叉排序树BST
susandebug
06-25 4467
前面总结了顺序查找，二分查找，分块查找算法，此篇博文将详解介绍二叉排序算法（Binary Sort Tree）。 在介绍二叉排序算法之前，首先介绍什么事二叉排序树（BST）。 首先从二叉树讲起： 1、二叉树的概念 二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（leftsubtree）和“右子树”（rightsubtree）。二叉树常被用作二叉查找树和二叉
阿里推荐算法（BST）
serenysdfg的博客
11-28 2876
2019.5月:Behavior Sequence Transformer for E-commerce Recommendation in Alibaba 论文地址:https://arxiv.org/pdf/1905.06874.pdf (阿里巴巴推荐系统搜索团队) 转自https://zhuanlan.zhihu.com/p/76570628 <<将Transformer...
c++中pHead指向第一个元素，并非是一个空
MonkeyMonkeyGo
06-06 1501
pHead-&gt;val就是第一个元素值。一直困扰好久，今天测试了一下。不然老是影响写程序。
BST二叉树算法精讲
小鱼仙倌的博客
06-17 438
树结构对于程序员来说应该不陌生，特别是二叉树，基本只要接触算法这一类的都一定会碰到的，所以我打算通过一篇文章，对二叉树结构的相关算法进行总结汇总，思路和代码实现相结合，让你不在惧怕二叉树。（ps：后面我还想写一篇树结构的高级篇，就是多叉数，就是对我平时看算法论文碰到的一些新奇的算法，比如B树、B+树，还有我一种叫做Bed树的新奇算法等等） 单纯就是想分享技术博文，还想说一句就是，如果觉得有用，请点个关注、给个赞吧，也算对我来说是个宽慰，毕竟也得掉不少头发，嘿嘿嘿。 下面的思路讲解中，我会给出一个类伪代码的思
二叉排序树（BST）/二叉查找树的建立(BST是笔试面试的常客)
热门推荐
认知 行动 坚持
06-09 8万+
二叉排序树又叫二叉查找树，英文名称是：Binary Sort Tree. BST的定义就不详细说了，我用一句话概括：左 。 根据这个原理，我们可以推断：BST的中序遍历必定是严格递增的。 在建立一个BST之前，大家可以做一下这个题目（很简单的）： 已知，某树的先序遍历为：4, 2, 1 ,0, 3, 5, 9, 7, 6, 8. 中序遍历为: 0, 1, 2
C++数据结构与算法：高校经典教程
“c++数据结构与算法”是一本经典教材，适合C++初学者和有经验的程序员，旨在探讨数据结构和算法设计。 在计算机科学中，数据结构和算法是两个至关重要的概念。数据结构是关于如何组织和存储数据的方式，以便更有效...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值