代码随想录训练第十四天|LeetCode513.找树左下角的值、LeetCode112.路径总和、LeetCode113. 路径总和ii、LeetCode106.从中序与后续遍历序列构造二叉树

已于 2024-07-09 01:40:32 修改
阅读量969 收藏 29
点赞数 14
分类专栏： 代码随想录 文章标签： java 学习 数据结构 算法 leetcode
于 2024-07-08 01:13:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60364343/article/details/140255440
版权

文章目录

513.找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

img

输入: root = [2,1,3]
输出: 1

示例 2:

img

输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7

提示:

  • 二叉树的节点个数的范围是 [1,104]
  • -231 <= Node.val <= 231 - 1

Related Topics

  • 树
  • 深度优先搜索
  • 广度优先搜索
  • 二叉树

思路

本题要找出树的最后一行的最左边的值。此时大家应该想起用层序遍历是非常简单的了，反而用递归的话会比较难一点。

递归法

咋眼一看，这道题目用递归的话就就一直向左遍历，最后一个就是答案呗？

没有这么简单，一直向左遍历到最后一个，它未必是最后一行啊。

我们来分析一下题目：在树的最后一行找到最左边的值。

首先要是最后一行，然后是最左边的值。

如果使用递归法，如何判断是最后一行呢，其实就是深度最大的叶子节点一定是最后一行。

如果对二叉树深度和高度还有点疑惑的话，请看：110.平衡二叉树 (opens new window)。

所以要找深度最大的叶子节点。

那么如何找最左边的呢？可以使用前序遍历（当然中序，后序都可以，因为本题没有 中间节点的处理逻辑，只要左优先就行），保证优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。

递归三部曲：

  1. 确定递归函数的参数和返回值

参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。 这里就不需要返回值了，所以递归函数的返回类型为void。

本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。

	//使用全局变量,递归就不需要返回值了
	private int res=0;
	private int maxDepth=-1;
	/**
	 * @Description 递归法,用来遍历所有节点,
	 * @Param node 当前节点
	 * @Param depth 当前深度
	 * @Return
	 * @Author 君君
	 * @Date 2024/7/7 0:36
	 */
	private void traversal(TreeNode node,int depth)
	{

	}
  1. 确定终止条件

当遇到叶子节点的时候，叶子节点就是左右子节点都为null,就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。

代码如下：

		//遇到叶子节点,记录节点值
		if(node.left==null&&node.right==null)
		{
			//如果当前当前节点的深度比最大深度深
			//则更新结果值,如果是等于的话,就相当于同深度的其他节点
			//只要保证节点的遍历顺序,使第一个遍历的永远是左节点,就可以保证,最大深度的最左节点永远是最先记录的
			if(depth>maxDepth){
				//更新最大深度
				maxDepth = depth;
				//更新节点值
				res=node.val;
			}
			return;
		}
  1. 确定单层递归的逻辑

在找最大深度的时候，递归的过程中依然要使用回溯，代码如下：

		//先向左遍历,保证先遍历最左节点
		if(node.left!=null)
		{
			depth++;
			traversal(node.left, depth);
			//回溯
			depth--;
		}
		if(node.right!=null)
		{
			depth++;
			traversal(node.right, depth);
			//回溯
			depth--;
		}

完整代码

class Solution {
	//使用全局变量,递归就不需要返回值了
	private int res=0;
	private int maxDepth=-1;
    public int findBottomLeftValue(TreeNode root) {
		traversal(root,0);
		return res;
    }

	/**
	 * @Description 递归法,用来遍历所有节点,
	 * @Param node 当前节点
	 * @Param depth 当前深度
	 * @Return
	 * @Author 君君
	 * @Date 2024/7/7 0:36
	 */
	private void traversal(TreeNode node,int depth)
	{
		//遇到叶子节点,记录节点值
		if(node.left==null&&node.right==null)
		{
			//如果当前当前节点的深度比最大深度深
			//则更新结果值,如果是等于的话,就相当于同深度的其他节点
			//只要保证节点的遍历顺序,使第一个遍历的永远是左节点,就可以保证,最大深度的最左节点永远是最先记录的
			if(depth>maxDepth){
				//更新最大深度
				maxDepth = depth;
				//更新节点值
				res=node.val;
			}
			return;
		}
		//先向左遍历,保证先遍历最左节点
		if(node.left!=null)
		{
			depth++;
			traversal(node.left, depth);
			//回溯
			depth--;
		}
		if(node.right!=null)
		{
			depth++;
			traversal(node.right, depth);
			//回溯
			depth--;
		}
	}
}

时间复杂度O(n)

空间复杂度O(n)

只要保证节点的遍历顺序,使第一个遍历的永远是左节点,就可以保证,最大深度的最左节点永远是最先记录的

迭代法

本题使用层序遍历再合适不过了，比递归要好理解得多！

只需要记录最后一行第一个节点的数值就可以了。

如果对层序遍历不了解，看这篇二叉树：层序遍历登场！ (opens new window)，这篇里也给出了层序遍历的模板，稍作修改就一过刷了这道题了。

代码如下：

/**
 * @Description 迭代法
 * @Param root
 * @Return {@link int}
 * @Author 君君
 * @Date 2024/7/7 0:50
 */
public int findBottomLeftValue(TreeNode root) {
    if (root == null) {
        return -1;
    }
    int res = 0;
    Deque<TreeNode> deque = new LinkedList<>();
    deque.offer(root);
    while (!deque.isEmpty()) {
        int size = deque.size();
        for (int i = 0; i < size; i++) {
            TreeNode temp = deque.poll();
            if (i == 0) {
                res = temp.val;
            }
            //在层序遍历中,使用队列,队列是先进先出,所以直接按照中左右的顺序去处理节点.
            if (temp.left != null) {
                deque.offer(temp.left);
            }
            if (temp.right != null) {
                deque.offer(temp.right);
            }
        }
    }
    return res;
}

时间复杂度O(n)

空间复杂度O(n)

总结

本题涉及如下几点：

112.路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：

img

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

img

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

  • 树中节点的数目在范围 [0, 5000] 内
  • -1000 <= Node.val <= 1000
  • -1000 <= targetSum <= 1000

Related Topics

  • 树
  • 深度优先搜索
  • 广度优先搜索
  • 二叉树

思路

相信很多同学都会疑惑，递归函数什么时候要有返回值，什么时候没有返回值，特别是有的时候递归函数返回类型为bool类型。

那么接下来我通过详细讲解如下两道题，来回答这个问题：

这道题我们要遍历从根节点到叶子节点的路径看看总和是不是目标和。

递归法

可以使用深度优先遍历的方式（本题前中后序都可以，无所谓，因为中节点也没有处理逻辑）来遍历二叉树

  1. 确定递归函数的参数和返回类型

参数：需要二叉树的根节点，还需要一个计数器，这个计数器用来计算二叉树的一条边之和是否正好是目标和，计数器为int型。

再来看返回值，递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

  • 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）
  • 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）
  • 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）

而本题我们要找一条符合条件的路径，所以递归函数需要返回值，及时返回，那么返回类型是什么呢？

如图所示：

112.路径总和

图中可以看出，遍历的路线，并不要遍历整棵树，所以递归函数需要返回值，可以用bool类型表示。

所以代码如下：

/**
 * @Description
 * @Param node 当前节点
 * @Param count 当前遍历的路径和
 * @Return {@link boolean}
 * @Author 君君
 * @Date 2024/7/7 1:15
 */
private boolean traversal(TreeNode node, int count){
    
}
  1. 确定终止条件

首先计数器如何统计这一条路径的和呢？

不要去累加然后判断是否等于目标和，那么代码比较麻烦，可以用递减，让计数器count初始为目标和，然后每次减去遍历路径节点上的数值。

如果最后count == 0，同时到了叶子节点的话，说明找到了目标和。

如果遍历到了叶子节点，count不为0，就是没找到。

递归终止条件代码如下：

	//此处省去对头结点的判断
    //先将当前节点的值从目标值中减去
    count -= node.val;
    //找到叶子节点
    if (node.left == null && node.right == null) {
        //判断结果值是否等于0(确定存在路径符合要求)
        return count == 0 ? true : false;
    }
  1. 确定单层递归的逻辑

因为终止条件是判断叶子节点，所以递归的过程中就不要让空节点进入递归了。

递归函数是有返回值的，如果递归函数返回true，说明找到了合适的路径，应该立刻返回。

代码如下：

	if (node.left != null) {
        boolean left = traversal(node.left, count);
        //找到了目标
        if (left)
            return true;
    }
    if (node.right != null) {
        boolean right = traversal(node.right, count);
        //找到了目标
        if (right)
            return true;
    }
    //未找到目标值
    return false;

整体代码

public boolean hasPathSum(TreeNode root, int targetSum) {
    //将头节点的判断放在此处
    if (root == null) {
        return false;
    }
    return traversal(root, targetSum);
}

/**
 * @Description
 * @Param node 当前节点
 * @Param count 当前遍历的路径和
 * @Return {@link boolean}
 * @Author 君君
 * @Date 2024/7/7 1:15
 */
private boolean traversal(TreeNode node, int count) {
    //此处省去对头结点的判断
    //先将当前节点的值从目标值中减去
    count -= node.val;
    //找到叶子节点
    if (node.left == null && node.right == null) {
        //判断结果值是否等于0(确定存在路径符合要求)
        return count == 0 ? true : false;
    }
    if (node.left != null) {
        boolean left = traversal(node.left, count);
        //找到了目标
        if (left)
            return true;
    }
    if (node.right != null) {
        boolean right = traversal(node.right, count);
        //找到了目标
        if (right)
            return true;
    }
    //未找到目标值
    return false;
}

时间复杂度O(n)

空间复杂度O(n)

迭代法

/**
 * @Description 迭代法(前序遍历)
 * @Param root
 * @Param targetSum
 * @Return {@link boolean}
 * @Author 君君
 * @Date 2024/7/7 1:47
 */
public boolean hasPathSum(TreeNode root, int targetSum) {
    //将头节点的判断放在此处
    if (root == null) {
        return false;
    }
    //第一个用来存储遍历节点
    Stack<TreeNode> stack1 = new Stack<>();
    //第二个用来存储节点值
    Stack<Integer> stack2 = new Stack<>();
    stack1.push(root);
    stack2.push(root.val);
    while (!stack1.isEmpty()) {
        int size = stack1.size();
        for (int i = 0; i < size; i++) {
            //找到当前要处理的节点
            TreeNode temp = stack1.pop();
            //当前节点的路径和
            int sum = stack2.pop();
            //找到叶子节点(中)
            if (temp.left == null && temp.right == null && sum == targetSum) {
                return true;
            }
            //右
            if (temp.right != null) {
                stack1.push(temp.right);
                stack2.push(sum + temp.right.val);
            }
            //左
            if (temp.left != null) {
                stack1.push(temp.left);
                stack2.push(sum + temp.left.val);
            }
        }
    }
    return false;
}

时间复杂度O(n)

空间复杂度O(n)

113. 路径总和ii

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

叶子节点 是指没有子节点的节点。

示例 1：

img

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

img

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

  • 树中节点总数在范围 [0, 5000] 内
  • -1000 <= Node.val <= 1000
  • -1000 <= targetSum <= 1000

Related Topics

  • 树

  • 深度优先搜索

  • 回溯

  • 二叉树

思路

路径总和ii要遍历整个树，找到所有路径，所以递归函数不要返回值！

如图：

113.路径总和ii

递归法

可以使用深度优先遍历的方式（本题前中后序都可以，无所谓，因为中节点也没有处理逻辑）来遍历二叉树

  1. 确定递归函数的参数和返回类型

首先已经确定了当前的返回类型,由于当前要遍历所有节点,所以不需要返回值.

由于要使用到当前节点,所以需要一个TreeNode,

还需要一个一维数组用来记录已经遍历过的路径,

一个数字用来简化代码流程:已经得到的路径和不需要这个数组来计算,直接参数传递就好

所以代码如下：

private void traversal(List<Integer> path, TreeNode node, int count){
    ...
}
  1. 确定递归出口

由于要判断是否为叶子结点,也需要将符合要求的数组加入结果集中

/如果当前节点是叶子节点,则进行count的判断
    if (node.left == null && node.right == null && count == 0) {
        res.add(new ArrayList<>(path));
    }
  1. 单层代码逻辑
if (node.left != null) {
        //递归
        path.add(node.left.val);
        traversal(path, node.left, count - node.left.val);
        //回溯
        path.remove(path.size() - 1);
    }
    if (node.right != null) {
        //递归
        path.add(node.right.val);
        traversal(path, node.right, count - node.right.val);
        //回溯
        path.remove(path.size() - 1);
    }

整体代码

List<List<Integer>> res = new ArrayList<>();

public List<List<Integer>> pathSum(TreeNode root, int targetSum) {
    List<Integer> path = new ArrayList<>();
    //在递归入口处去除空节点
    if (root == null) {
        return res;
    }
    path.add(root.val);
    traversal(path, root, targetSum-root.val);
    return res;
}

/**
 * @Description 递归法
 * @Param node 当前节点
 * @Param count 减去当前节点val剩下的值.
 * @Return
 * @Author 君君
 * @Date 2024/7/7 20:57
 */
private void traversal(List<Integer> path, TreeNode node, int count) {
	//在此时node!=null
    //如果当前节点是叶子节点,则进行count的判断
    if (node.left == null && node.right == null && count == 0) {
        res.add(new ArrayList<>(path));
    }
    if (node.left != null) {
        //递归
        path.add(node.left.val);
        traversal(path, node.left, count - node.left.val);
        //回溯
        path.remove(path.size() - 1);
    }
    if (node.right != null) {
        //递归
        path.add(node.right.val);
        traversal(path, node.right, count - node.right.val);
        //回溯
        path.remove(path.size() - 1);
    }
}

时间复杂度O(n)

空间复杂度O(n)

106.从中序与后续遍历序列构造二叉树

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

img

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

示例 2:

输入：inorder = [-1], postorder = [-1]
输出：[-1]

提示:

  • 1 <= inorder.length <= 3000

  • postorder.length == inorder.length

  • -3000 <= inorder[i], postorder[i] <= 3000

  • inorder 和 postorder 都由 不同 的值组成 ,这点比较重要,如果看值,那么如果有重复值,则在寻找中间节点的时候就会出现问题

  • postorder 中每一个值都在 inorder 中

  • inorder 保证是树的中序遍历

  • postorder 保证是树的后序遍历

Related Topics

  • 树
  • 数组
  • 哈希表
  • 分治
  • 二叉树

思路

首先回忆一下如何根据两个顺序构造一个唯一的二叉树，相信理论知识大家应该都清楚，就是以 后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

如果让我们肉眼看两个序列，画一棵二叉树的话，应该分分钟都可以画出来。

流程如图：

106.从中序与后序遍历序列构造二叉树

那么代码应该怎么写呢？

说到一层一层切割，就应该想到了递归。

来看一下一共分几步：

  • 第一步：如果数组大小为零的话，说明是空节点了。
  • 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
  • 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
  • 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）
  • 第五步：切割后序数组，切成后序左数组和后序右数组
  • 第六步：递归处理左区间和右区间

不难写出如下代码：（先把框架写出来）

	private TreeNode traversal(int[] inorder,int[] postorder){
		// 第一步
		if (postorder.length == 0) return null;

		//第二步,找到后序数组的最后值,也就是中间节点
		int rootVal = postorder[postorder.length-1];
		//创建一个当前节点
		TreeNode root = new TreeNode(rootVal);

		//叶子节点,当前分支已经遍历结束
		if(postorder.length==1)
			return root;

		//第三步,在中序遍历数组中找到切割点
		int index1;
		for (index1 = 0; index1 < inorder.length; index1++) {
			//如找到目标节点,退出循环
			if(inorder[index1]==rootVal)
				break;
		}

		//第四步,使用切割点,切割中序数组,得到中序左数组以及中序右数组

		//第五步,使用中序左数组切割后续数组,得到后序左数组和后续右数组

		//第六步
		root.left =traversal(中序左数组, 后序左数组);
		root.left =traversal(中序右数组, 后序右数组);
	}

难点大家应该发现了，就是如何切割，以及边界值找不好很容易乱套。

此时应该注意确定切割的标准，是左闭右开，还有左开右闭，还是左闭右闭，这个就是不变量，要在递归中保持这个不变量。

在切割的过程中会产生四个区间，把握不好不变量的话，一会左闭右开，一会左闭右闭，必然乱套！

我在数组：每次遇到二分法，都是一看就会，一写就废 (opens new window)和数组：这个循环可以转懵很多人！ (opens new window)中都强调过循环不变量的重要性，在二分查找以及螺旋矩阵的求解中，坚持循环不变量非常重要，本题也是。

首先要切割中序数组，为什么先切割中序数组呢？

切割点在后序数组的最后一个元素，就是用这个元素来切割中序数组的，所以必要先切割中序数组。

中序数组相对比较好切，找到切割点（后序数组的最后一个元素）在中序数组的位置，然后切割，如下代码中我坚持左闭右开的原则：

	//map方便跟根据数值查找位置,第一个参数为val,第二个参数为index
	Map<Integer,Integer> map;
    public TreeNode buildTree(int[] inorder, int[] postorder) {
		map = new HashMap<>();
		for (int i = 0; i < inorder.length; i++) {
			map.put(inorder[i],i);
		}
		//前闭后开
		TreeNode res = traversal(inorder,  0, inorder.length, postorder,0, postorder.length);
		return res;
    }

	/**
	 * @Description 由于java数组的大小是固定的,所以可以使用两个节点值加上原来数组代表一段数组 使用左闭右开区间
	 * @Param inorder
	 * @Param inBegin
	 * @Param inEnd
	 * @Param postorder
	 * @Param postBegin
	 * @Param postEnd
	 * @Return {@link TreeNode}
	 * @Author 君君
	 * @Date 2024/7/8 0:41
	 */
	private TreeNode traversal(int[] inorder,int inBegin, int inEnd,int[] postorder,int postBegin, int postEnd){
		// 第一步
		if(postBegin>=postEnd||inBegin>=inEnd)
		{
			return null;
		}
		//第二步,找到后序数组的最后值,也就是中间节点
		int rootIndex = map.get(postorder[postEnd-1]);
		//创建一个当前节点
		TreeNode root = new TreeNode(inorder[rootIndex]);


		//第三步,在中序遍历数组中找到切割点
		//保存中序左子树个数，用来确定后序数列的个数
		int lenOfLeft = rootIndex - inBegin;

		//第四步,使用切割点,切割中序数组,得到中序左数组以及中序右数组
		//第五步,使用中序左数组切割后续数组,得到后序左数组和后续右数组
		//第六步,递归
		root.left =traversal(inorder,inBegin, rootIndex,postorder,postBegin,postBegin + lenOfLeft);
		root.right =traversal(inorder,rootIndex+1,inEnd ,postorder,postBegin + lenOfLeft,postEnd - 1);
	return root;
	}

时间复杂度O(n)

空间复杂度O(n)

105.从前序与中序遍历序列构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

示例 1:

img

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

  • 1 <= preorder.length <= 3000
  • inorder.length == preorder.length
  • -3000 <= preorder[i], inorder[i] <= 3000
  • preorder 和 inorder 均 无重复 元素
  • inorder 均出现在 preorder
  • preorder 保证 为二叉树的前序遍历序列
  • inorder 保证 为二叉树的中序遍历序列

Related Topics

  • 树

  • 数组

  • 哈希表

  • 分治

  • 二叉树

思路

本题和106是一样的道理。

我就直接给出代码了。

Map<Integer, Integer> map = new HashMap<>();

public TreeNode buildTree(int[] preorder, int[] inorder) {
    for (int i = 0; i < inorder.length; i++) { // 用map保存中序序列的数值对应位置
        map.put(inorder[i], i);
    }
    return traversal(inorder, 0, inorder.length, preorder, 0, preorder.length);
}

private TreeNode traversal(int[] inorder, int inBegin, int inEnd, int[] preorder, int preBegin, int preEnd) {
    if (inBegin >= inEnd || preBegin >= preEnd) {
        return null;
    }
    //找到前序遍历的第一个节点,也就是中间节点
    int rootIndex = map.get(preorder[preBegin]);
    TreeNode root = new TreeNode(inorder[rootIndex]);
    //保存中序遍历左子树的个数,用来分割前序遍历的数组.
    int lenOfLeft = rootIndex - inBegin;
    root.left = traversal(inorder, inBegin, rootIndex, preorder, preBegin + 1, preBegin + 1 + lenOfLeft);
    root.right = traversal(inorder, rootIndex + 1, inEnd, preorder, preBegin + 1 + lenOfLeft, preEnd);
    return root;
}

时间复杂度O(n)

空间复杂度O(n)

君君超有趣
关注
  • 14
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值