leetcode二叉树面试题目集锦

已于 2024-03-02 21:26:17 修改
阅读量6.8k 收藏 29
点赞数 4
分类专栏： C++ Leetcode/剑指offer/算法/数据结构 文章标签： leetcode 面试 算法
于 2018-08-18 10:07:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiangxianghehe/article/details/81805957
版权

优势

在实际使用时会根据链表和有序数组等数据结构的不同优势进行选择。有序数组的优势在于二分查找，链表的优势在于数据项的插入和数据项的删除。但是在有序数组中插入数据就会很慢，同样在链表中查找数据项效率就很低。综合以上情况，二叉树可以利用链表和有序数组的优势，同时可以合并有序数组和链表的优势，二叉树也是一种常用的数据结构。

定义

二叉树由节点（node）和边组成。节点分为根节点、父节点、子节点。如下图所示

这里写图片描述

红色是根节点root。蓝色是子节点也是父节点，绿色的是子节点。其余的线是边。节点和链表中的节点一样都可以存放数据信息。树中的边可以用自引用表示，这种引用就是C/C++里面的指针。通常来说树是顶部小，底部大，且树呈分层结构。root节点时第0层，以此类推。另外, 二叉树最多有两个节点。

###结构体定义

struct BinaryTreeNode { 
    int value; 
    BinaryTreeNode* left; 
    BinaryTreeNode* right; 
    BinaryTreeNode(int x) : value(x), left(NULL), right(NULL) {} 
};

初始化

我们直接简单初始化:根节点为1,左节点为2,右节点为3,如图所示:

这里写图片描述

对应code如下:

void init(BinaryTreeNode *root)
{
	root ->value = 1;
	BinaryTreeNode *left = new BinaryTreeNode(2);
	BinaryTreeNode *right = new BinaryTreeNode(3);
	root->left = left;
	root->right = right;	
	
}

可以直接把一个一个初始化好的二叉树接到节点上,例如:

这里写图片描述

对应code如下:

void init(BinaryTreeNode *root)
{
	root ->value = 1;
	BinaryTreeNode *head = new BinaryTreeNode(1);
	BinaryTreeNode *left = new BinaryTreeNode(2);
	BinaryTreeNode *right = new BinaryTreeNode(3);
	head -> left = left;
	head -> right = right;
	root -> left = head;
	root -> right = head;
	
}

求二叉树节点个数

/*
    如果二叉树为空，节点个数为0
    如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1
*/

int getNodenum(BinaryTreeNode *head)
{
	if(head  == nullptr)	 return 0;
	else
	{
		return getNodenum(head->left) + getNodenum(head->right) +1;
	}
	
}

求二叉树的深度

/*

    如果二叉树为空，二叉树的深度为0
    如果二叉树不为空，二叉树的深度 = max(左子树深度， 右子树深度) + 1

*/

int getDegree(BinaryTreeNode *head)
{
	if(head == nullptr) 	return 0;
	else
	{
		int max_degree =  getDegree(head->left)>getDegree(head->right)?getDegree(head->left):getDegree(head->right);
		return max_degree + 1;
	}
}

前序遍历，中序遍历，后序遍历

三种遍历其实用递归很容易,不过还是建议也顺便掌握下非递归遍历方法.

前序遍历递归解法：如果二叉树为空，空操作；如果二叉树不为空，访问根节点，前序遍历左子树，前序遍历右子树。

中序遍历递归解法：如果二叉树为空，空操作；如果二叉树不为空，中序遍历左子树，访问根节点，中序遍历右子树。

后序遍历递归解法：如果二叉树为空，空操作；如果二叉树不为空，后序遍历左子树，后序遍历右子树，访问根节点。

代码如下:

void preOrderTraverse(BinaryTreeNode* head)
{
	if(head == nullptr) 	return ;
	else
	{
		cout << head->value <<endl;
		preOrderTraverse(head -> left);
		
		preOrderTraverse(head -> right);
	}
	
}


void inOrderTraverse(BinaryTreeNode* head)
{
	if(head == nullptr) 	return ;
	else
	{
		inOrderTraverse(head -> left);
		cout << head->value <<endl;
		inOrderTraverse(head -> right);
	}	
	
}

void postOrderTraverse(BinaryTreeNode* head)
{
	if(head == nullptr) 	return ;
	else
	{
		postOrderTraverse(head -> left);
		postOrderTraverse(head -> right);
		cout << head->value <<endl;
	}
	
}

层次遍历

二叉树层次遍历相当于广度优先搜索，使用队列实现。队列初始化，将根节点压入队列。当队列不为空，进行如下操作：弹出一个节点，访问，若左子节点或右子节点不为空，将其压入队列。

void LevelTraverse(BinaryTreeNode* root) 
{ 
	if(root == NULL) return ; 
	queue<BinaryTreeNode*> que; 
	que.push(root); 
	while(!que.empty()) 
	{ 
		BinaryTreeNode* tempNode = que.front();
		que.pop(); 
		visit(tempNode); //cout <<tempNode->value <<endl;
		if(root->left != NULL) que.push(tempNode->left); 
		if(root->right != NULL) que.push(tempNode->right); 
	} 
	return ; 
}

求二叉树第K层的节点个数

这个可以用递归思路很快求解:

如果二叉树为空或者k<1返回0
如果二叉树不为空并且k==1，返回1
如果二叉树不为空且k>1，返回左子树中k-1层的节点个数与右子树k-1层节点个数之和

代码如下:

int getKthnum(BinaryTreeNode* head, int k)
{
	if(head == nullptr || k < 1) return 0;
	if (k==1)  return 1;
	int left_num = getKthnum(head->left);
	int right_num = getKthnum(head->right);
	return left_num + right_num;

}

求二叉树中叶子节点的个数

这个可以用递归思路也可以很快求解:

如果二叉树为空，返回0；
如果二叉树不为空且左右子树为空，返回1；
如果二叉树不为空，且左右子树不同时为空，返回左子树中叶子节点个数加上右子树中叶子节点个数。

int GetLeafNodeNum(BinaryTreeNode * head)  
{
	if(head == nullptr)  return 0;
	if (head->left == nullptr && head->right ==nullptr) return 1;
	int left_num =  GetLeafNodeNum(head->left);
	int right_num = GetLeafNodeNum(head->right);
	return left_num + right_num;
}

判断两棵二叉树是否结构相同

不考虑数据内容。结构相同意味着对应的左子树和对应的右子树都结构相同。这个可以用递归思路也可以很快求解:

如果两棵二叉树都为空，返回真
如果两棵二叉树一棵为空，另一棵不为空，返回假
如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假

bool isBinarytreeEqual(BinaryTreeNode * tree1, BinaryTreeNode * tree2)
{
	if(tree1 == nullptr && tree2 == nullptr) return true;
	else if(tree1 == nullptr || tree2 == nullptr) return false;
	else
	{
		
		bool isLeftEqual = isBinarytreeEqual(tree1->left, tree2->left);
		bool isRightEqual = isBinarytreeEqual(tree1->right, tree2->right);
		return (tree1->value == tree2->value )&&isLeftEqual && isRightEqual;
	}

}

判断一棵树是否是平衡二叉树

根据二叉树的定义，我们可以递归遍历二叉树的每一个节点来，求出每个节点的左右子树的高度，如果每个节点的左右子树的高度相差不超过1，按照定义，它就是一颗平衡二叉树。

class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if(root == nullptr)
            return true;
        int left = depth(root->left);
        int right =  depth(root->right);
        bool flag = abs(left - right) <=1?true:false;
        return flag && isBalanced(root->left) && isBalanced(root->right);
    }
    int depth(TreeNode* root)
    {
        if(root == nullptr)
            return 0;
        int left_depth = depth(root->left);
        int right_depth =  depth(root->right);
        return max(left_depth, right_depth) + 1;
    }
};

二叉树翻转(二叉树镜像)

这里是要求把二叉树进行左右子树翻转

递归实现:

#include<iostream>
using namespace std;

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot==NULL)
        {
            return;
        }
     swap(pRoot->left,pRoot->right);
     Mirror(pRoot->right);
     Mirror(pRoot->left);
    }
};

或者

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == nullptr)
            return nullptr;  
        invertTree(root->right);
        invertTree(root->left);
        swap(root->left,root->right);
        /*
        TreeNode* tmp =  root->left;
        root->left = root->right;
	    root->right = tmp;
        */
        return root;
        
    }
};

非递归实现:

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        if(pRoot==NULL)
        {
            return;
        }
        queue<TreeNode*>  q;
        q.push(pRoot);
        while(!q.empty())
        {
            TreeNode *per = q.front();
            TreeNode *tmp = per->left;
            per->left = per->right;
            per->right = tmp;
            if(per->right!=NULL)
            {
                q.push(per->right);
            }
            if(per->left!=NULL)
            {
                q.push(per->left);
            }
        }
        q.pop();

    }
}

二叉树的右视图（二叉树最右边节点）

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

其实就是考察二叉树的层次遍历，用队列实现：

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ivec;
        if(root != nullptr)
        {
            queue<TreeNode*> Queue;
            Queue.push(root);
            while(!Queue.empty())
            {
                ivec.push_back(Queue.front()->val);
                int size = Queue.size();
                for(int i = 1;i <= size;++i)
                {
                    TreeNode *Node = Queue.front();
                    Queue.pop();
                    if(Node->right != NULL)
                        Queue.push(Node->right);                    
                    if(Node->left != NULL)
                        Queue.push(Node->left);
 
                }
            }
            
        }
        return ivec;
        
    }
};

leetcode 124. 二叉树中的最大路径和，见：https://leetcode.cn/problems/binary-tree-maximum-path-sum。

二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不一定经过根节点。
路径和是路径中各节点值的总和。
给你一个二叉树的根节点 root ，返回其最大路径和 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxPathSum(TreeNode* root) {
        int max_sum = INT_MIN;
        maxPathSumHelper(root, max_sum);
        return max_sum;
    }

private:
    int maxPathSumHelper(TreeNode* node, int& max_sum) {
        if (node == nullptr) {
            return 0;
        }

        int left_sum = std::max(0, maxPathSumHelper(node->left, max_sum));
        int right_sum = std::max(0, maxPathSumHelper(node->right, max_sum));

        max_sum = std::max(max_sum, left_sum + right_sum + node->val);

        return std::max(left_sum, right_sum) + node->val;
    }
};

代码合并起来

#include <iostream>
using namespace std;

struct BinaryTreeNode { 
    int value; 
    BinaryTreeNode* left; 
    BinaryTreeNode* right; 
    BinaryTreeNode(int x) : value(x), left(nullptr), right(nullptr) {} 
};


/*
    如果二叉树为空，节点个数为0
    如果二叉树不为空，二叉树节点个数 = 左子树节点个数 + 右子树节点个数 + 1
*/

int getNodenum(BinaryTreeNode *head)
{
	if(head  == nullptr)	 return 0;
	else
	{
		return getNodenum(head->left) + getNodenum(head->right) +1;
	}
	
}

/*

    如果二叉树为空，二叉树的深度为0
    如果二叉树不为空，二叉树的深度 = max(左子树深度， 右子树深度) + 1

*/

int getDegree(BinaryTreeNode *head)
{
	if(head == nullptr) 	return 0;
	else
	{
		int max_degree =  getDegree(head->left)>getDegree(head->right)?getDegree(head->left):getDegree(head->right);
		return max_degree + 1;
		
	}
	
}



void init(BinaryTreeNode *root)
{
	root ->value = 1;
	BinaryTreeNode *head = new BinaryTreeNode(1);
	BinaryTreeNode *left = new BinaryTreeNode(2);
	BinaryTreeNode *right = new BinaryTreeNode(3);
	head -> left = left;
	head -> right = right;
	root -> left = head;
	root -> right = head;
}


void preOrderTraverse(BinaryTreeNode* head)
{
	if(head == nullptr) 	return ;
	else
	{
		cout << head->value <<endl;
		preOrderTraverse(head -> left);
		
		preOrderTraverse(head -> right);
	}
	
}


void inOrderTraverse(BinaryTreeNode* head)
{
	if(head == nullptr) 	return ;
	else
	{
		inOrderTraverse(head -> left);
		cout << head->value <<endl;
		inOrderTraverse(head -> right);
	}	
	
}

void postOrderTraverse(BinaryTreeNode* head)
{
	if(head == nullptr) 	return ;
	else
	{
		postOrderTraverse(head -> left);
		postOrderTraverse(head -> right);
		cout << head->value <<endl;
	}
	
}


int getKthnum(BinaryTreeNode* head, int k)
{
	if(head == nullptr || k < 1) return 0;
	if (k==1)  return 1;
	int left_num = getKthnum(head->left, k-1);
	int right_num = getKthnum(head->right, k-1);
	return left_num + right_num;

}


int GetLeafNodeNum(BinaryTreeNode * head)  
{
	if(head == nullptr)  return 0;
	if (head->left == nullptr && head->right ==nullptr) return 1;
	int left_num =  GetLeafNodeNum(head->left);
	int right_num = GetLeafNodeNum(head->right);
	return left_num + right_num;
}

int treeDepth(BinaryTreeNode * root)
{
	if(root == nullptr) return 0;
	int nLeft=treeDepth(root->left);
	int nright=treeDepth(root->right);
	return nLeft>nright?nLeft+1:nright+1;
	
}

bool isAVL(BinaryTreeNode * root)
{
	if(root == nullptr) return true;
	int left= treeDepth(root->left);
    int right= treeDepth(root->right);
	return abs(left - right) <=1?true:false;
	
	
}



int main()
{
	BinaryTreeNode *root;
	init(root);

	int degree = getDegree(root);
	cout <<"degree is: "<<endl;
	cout <<degree <<endl;
	cout << "preOrderTraverse result : "<<endl;
	preOrderTraverse(root);
	cout << "inOrderTraverse result : "<<endl;
	inOrderTraverse(root);
	cout << "postOrderTraverse result : "<<endl;
	postOrderTraverse(root);
	int kth_num = getKthnum(root, 3);
	cout << "number of node in 3th level is" <<endl;
	cout << kth_num <<endl;
	
	

	int n = getNodenum(root);
	cout << "number of all node is" <<endl;
	cout << n <<endl;
	int leaf_num = GetLeafNodeNum(root);
	cout <<"the number of leaf node is: "<<endl;
	cout <<leaf_num<<endl;
	cout <<"is root AVL? "<<isAVL(root)<<endl;
	
	
	return 0;
	
	
}
nudt_qxx
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
leetcode卡-leetcode-binary-tree-card:LeetCode二叉树卡片问题的章节智解
07-06
总的来说，LeetCode二叉树卡片问题的章节智解是IT专业人士提升自身技能、拓宽视野的好资源，它覆盖了二叉树的基本概念、重要性质和解题技巧，对于任何想要在算法领域深耕的人来说，都是不容错过的学习材料。
leetcode算法面试题：二叉树相关问题汇总（层序遍历、后序遍历、前序遍历、右视图、中序遍历、最大深度、最小深度、展开为链表、最大路径和、二叉搜索树）
白话机器学习
05-24 71
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。示例：二叉树：[3,9,20,null,null,15,7],   3   / \ 9 20   / \   15   7 返回其层序遍历结果： [ [3], [9,20], [15,7] ] 参考答案 二叉树层序遍历2 给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右
【leetcode刷题之路】面试经典150题（1）——数组/字符串
xtcc的博客
02-16 1252
新年第一更，祝大家都找到满意的offer！！！
2024年最全leetcode 最常见的150道前端面试题（简单题下），快速上手
最新发布
2401_84447149的博客
05-07 858
编程基础的初级开发者，计算机科学专业的学生，以及平时没怎么利用过数据结构与算法的开发人员希望复习这些概念为下次技术面试做准备。或者想学习一些计算机科学的基本概念，以优化代码，提高编程技能。这份笔记都是可以作为参考的。开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】
力扣高频|算法面试题汇总(十）：图论
qq_24739717的博客
05-31 1936
力扣高频|算法面试题汇总(十）：图论 力扣链接 目录： 1.单词接龙 1.单词接龙 给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则： 每次转换只能改变一个字母。 转换过程中的中间单词必须是字典中的单词。 说明: 如果不存在这样的转换序列，返回 0。 所有单词具有相同的长度。 所有单词只由小写字母组成。 字典中不存在重复的单词。 你可以假设 beginWord 和 endWord 是非空的，且二者
leetcode 最常见的 150 道前端面试题（简单题上）
热门推荐
前端开发博客
08-22 1万+
大家好，之前分享leetcode 最常见的150道前端面试题（简单题下）上篇来了。前言本文题目选自LeetCode 精选 TOP 面试题[1]，而这些题在自己和同事亲身经历中，确实遇到...
Symmetric Tree
aysd68784的博客
08-04 90
问题：判断二叉树是否为镜像二叉树分析：递归判断，根节点单独判断，然后递归左结点和右结点，之后每次一起递归左结点的左结点和右结点的右结点比较，左结点的右结点和右结点的左结点比较 /** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * ...
leetcode 平台题目实现代码
10-19
《LeetCode平台题目实现代码》是一本集合了LeetCode平台上众多算法题目的解题代码集，主要使用C++语言编写。这本书是编程爱好者和个人学习者的重要资源，它可以帮助读者提升在算法面试和数据结构理解方面的技能。...
leetcode经典题目全解析
05-27
LeetCode作为一个知名的在线编程练习平台，汇集了各种难度级别的编程题目，涵盖数据结构、算法、设计模式等多个领域，对于提升编程技能、准备面试以及深入理解计算机科学有着极高的价值。 这份文档的亮点在于它不仅...
leetcode 上面题目的解决代码
02-26
这个"leetcode-master"压缩包将包含以上各种知识点的具体应用示例，通过阅读和理解这些代码，你可以提升自己的编程技能，更好地应对面试和实际工作中的挑战。同时，这也是一个不断学习和实践的过程，因为LeetCode上...
leetcode答案-leetcode:leetcode题目答案与思考
06-30
首先，LeetCode上的题目涵盖了各种难度级别，从基础到高级，包括数组、链表、字符串、二叉树、图、排序和搜索算法等。通过解决这些题目，开发者可以提高他们的编程技巧，这对于面试准备和日常开发工作都非常有益。 ...
LeetCode上经典面试问题Java语言实现
12-21
这是个人搜集的LeetCode上一些经典面试问题的Java语言实现，涉及数组、链表、堆栈、队列、二叉树、并查集、字典树等15个维度，供各位学习参考使用！
数据结构——二叉树入门（二）判断两颗二叉树是否相同
Wz_still_shuai的博客
04-08 5766
一.判断两颗二叉树是否相同！ 分析： 什么叫做两棵树相同？ 1.树的结构相同： 节点数目要相同，深度要相同。 2.左子树与右子树相同： （递归的）每一刻左子树都要与右子树相同。 3.两棵空树也是相同的树。 如图： OK，现在就到了最开心的源码环节： //计算一棵二叉树的深度 int depthTree(TreeNode* root) { if (root == NULL...
判断两棵二叉树是否结构相同
奋斗、
05-09 2630
//不考虑数据内容。结构相同意味着对应的左子树和对应的右子树都结构相同。 //递归解法： //（1）如果两棵二叉树都为空，返回真 //（2）如果两棵二叉树一棵为空，另一棵不为空，返回假 //（3）如果两棵二叉树都不为空，如果对应的左子树和右子树都同构返回真，其他返回假 bool isSameStructure(BinaryTree* pRoot1,BinaryTree* pRoot2) { if
Leetcode 199.二叉树的右视图
Bing's Blog
09-03 260
Time: 20190903 Type: Medium 题目描述 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 示例: 输入: [1,2,3,null,5,null,4] 输出: [1, 3, 4] 解释: 1 <--- / \ 2 3 <--- \ \ 5 4...
二叉树经典算法题详解（灰常详细）
m0_74234485的博客
07-06 723
二叉树经典算法题解析
[LeetCode]199. 二叉树的右视图
zaker123的博客
04-23 312
题目 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 示例: 输入: [1,2,3,null,5,null,4] 输出: [1, 3, 4] 解释: 1 <--- / \ 2 3 <--- \ \ 5 4 <--- 解题思路 解法一：广度优先...
[C++算法] - 二叉树《21道常见的面试题》
Snoopy_Dream
10-21 843
自己动手写代码，记录中间出现的错误。 这个网址不错https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E6%A0%91.md 目录 中序遍历！ 先序遍历 后序遍历 按层遍历 不分行打印（deque） 分行打印（queue） Z字遍历（两个栈） Mo...
力扣199-二叉树的右视图-C++
TLJava^v^的博客
03-06 596
一、运行结果 二、题目 给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 示例 1: 输入:[1,2,3,null,5,null,4] 输出:[1,3,4] 示例 2: 输入:[1,null,3] 输出:[1,3] 示例 3: 输入:[] 输出:[] 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/binary-tree-right-side-view 三、...
LeetCode 精选 TOP 面试题（3）1
08-04
本次LeetCode精选TOP面试题涵盖了两道题目，分别是第一题和第九十八题。在第一题中，我们需要对一棵二叉树进行层次遍历，并给每一层的节点加上结尾标记N。在第九十八题中，我们需要验证给定的二叉树是否为二叉搜索树...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值