二叉树总结篇

已于 2024-09-16 17:40:54 修改
阅读量591 收藏 21
点赞数 16
分类专栏： 代码随想录 文章标签： 数据结构 算法 java 开发语言 链表
于 2024-09-16 17:38:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46321761/article/details/142300690
版权

二叉树的理论基础

二叉树的种类，存储方法，遍历方式，定义

二叉树的遍历

分为两种：深度和广度

深度分为三种：前序，中序，后序

处理问题的思路又分为两种：迭代和递归

迭代：要理解递归的思路并且熟练的使用它，就是要想清楚你想做什么(处理逻辑），什么时候停止。

递归：三要素，参数（决定了这个递归函数是否要独立写出来），结束条件，处理逻辑（可以先凶从二叉树处理分析逻辑）

就是迭代更直接，更好理解；

递归不好理解，但是代码很套路，摸清三要素

迭代

前序

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root){
        if (root == null){
            return res;
        }
       preorder(root);
        return res;
    }
   public void preorder(TreeNode root){
    if(root==null) 
    return ;
    res.add(root.val);
    preorder(root.left);
    preorder(root.right);
   }
}

中序

class Solution {
     List<Integer> result = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
       
        if (root == null){
            return result;
        }
     
        inorder(root);
        return result;
    }

    public void inorder(TreeNode root){
        if(root==null)
        return ;
        inorder(root.left);
        result.add(root.val);
        inorder(root.right);
    }
}

后序

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root) {
 
        if (root == null){
            return res;
        }
   
      postorder(root);
        return res;
    }
    public void postorder(TreeNode root){
        if(root==null) return ;
        postorder(root.left);
        postorder(root.right);
        res.add(root.val);
    }
  

}

层序

class Solution {
  public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res=new ArrayList<>();
        if(root==null) return res;
        Queue<TreeNode> quenue=new LinkedList<TreeNode>();
       
        quenue.offer(root);
     

        while(!quenue.isEmpty()){
          int len=quenue.size();
          List<Integer> aslist=new ArrayList<Integer>();
          while(len>0){
            TreeNode node=quenue.poll();
            aslist.add(node.val);
            len--;
            if(node.left!=null) quenue.offer(node.left);
            if(node.right!=null) quenue.offer(node.right);
        
          }
          res.add(aslist);

        }
return res;
    }
}

递归

借助栈这个存储空间

这里我选择使用统计递归的那个代码，只需要记住一个就行了，就和迭代的代码一样，只需要改变中左右的顺序就可以实现遍历功能

前序

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root){
        if (root == null){
            return res;
        }
    Stack<TreeNode> stack=new Stack<>();
    if(root!=null) stack.push(root);
    while(!stack.isEmpty()){
        TreeNode node=stack.peek();
        if(node!=null){
            stack.pop();
            if(node.right!=null) stack.push(node.right);
            if(node.left!=null) stack.push(node.left);
            stack.push(node);
            stack.push(null);
        }else{
            stack.pop();
            TreeNode n=stack.peek();
            stack.pop();
            res.add(n.val);
        }
    }
    return res;
    }
}

中序


class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root){
        if (root == null){
            return res;
        }
    Stack<TreeNode> stack=new Stack<>();
    if(root!=null) stack.push(root);
    while(!stack.isEmpty()){
        TreeNode node=stack.peek();
        if(node!=null){
            stack.pop();
            if(node.right!=null) stack.push(node.right);
            stack.push(node);
            stack.push(null);
            if(node.left!=null) stack.push(node.left);
            
        }else{
            stack.pop();
            TreeNode n=stack.peek();
            stack.pop();
            res.add(n.val);
        }
    }
    return res;
    }
}

后序

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> postorderTraversal(TreeNode root){
        if (root == null){
            return res;
        }
    Stack<TreeNode> stack=new Stack<>();
    if(root!=null) stack.push(root);
    while(!stack.isEmpty()){
        TreeNode node=stack.peek();
        if(node!=null){
            stack.pop();
               stack.push(node);
            stack.push(null);
            if(node.right!=null) stack.push(node.right);
             if(node.left!=null) stack.push(node.left);
            
        }else{
            stack.pop();
            TreeNode n=stack.peek();
            stack.pop();
            res.add(n.val);
        }
    }
    return res;
    }
}

层序

class Solution {
  public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res=new ArrayList<>();
        if(root==null) return res;
        
        dfs(1,root,res);
        return res;

    }

    public void dfs(int index,TreeNode root,List<List<Integer>> res){
        if(res.size()<index){
            res.add(new ArrayList<>());
        }

        res.get(index-1).add(root.val);
        if(root.left!=null)
        dfs(index+1,root.left,res);
        if(root.right!=null)
        dfs(index+1,root.right,res);
    }
}

二叉树的属性

对称二叉树

迭代

借助队列去实现

class Solution {
    public boolean isSymmetric(TreeNode root) {
    if(root==null)  return true;
    Queue<TreeNode> queue=new LinkedList<>();
    queue.offer(root.left);
    queue.offer(root.right);

    while(!queue.isEmpty()){
        TreeNode left=queue.poll();
        TreeNode right=queue.poll();

        if(left==null&&right==null)
        continue;
        if(left==null||right==null)
        return false;
        if(left.val!=right.val)
        return false;

        queue.offer(left.left);
        queue.offer(right.right);
        queue.offer(left.right);
        queue.offer(right.left);


    }
    return true;
    }
}

递归

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null)  return true;
        return compare(root.left,root.right);
}
public boolean compare(TreeNode left,TreeNode right){
    
    if(left==null&&right!=null) return false;
    if(left!=null&&right==null) return false;
    if(left==null&&right==null) return true;
    if(left.val!=right.val) return false;

    boolean inner=compare(left.right,right.left);
    boolean outside=compare(left.left,right.right);
    return inner&&outside; 
    }
}

二叉树的最大深度

迭代

层序遍历BFS

class Solution {
    public int maxDepth(TreeNode root) {
    int res=0;
    if(root==null) return res;

Queue<TreeNode> queue=new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
    int len=queue.size();
   
    while(len>0){
        TreeNode node=queue.poll();
        
        len--;
        if(node.left!=null) queue.offer(node.left);
        if(node.right!=null) queue.offer(node.right);
    }
    res++;
  
}
return res;
    }
}

递归

转换思路

求根节点最大高度就是最大深度

class Solution {
    public int maxDepth(TreeNode root) {
if(root==null) return 0;
return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }
}

二叉树的最小深度

迭代

利用层序遍历

 
class Solution {
    public int minDepth(TreeNode root) {
    int res=0;
    if(root==null) return res;
 
Queue<TreeNode> queue=new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
    int len=queue.size();
    res++;
    while(len>0){
    TreeNode   node=queue.poll();
        
        len--;
        if(node.left!=null) queue.offer(node.left);
        if(node.right!=null) queue.offer(node.right);
        if(node.left==null&&node.right==null)return res;
  
    }
   
    
}
return res;
    }
}

递归

求根节点最小高度就是最小深度

class Solution {
    public int minDepth(TreeNode root) {
    int res=Integer.MAX_VALUE;
    if(root==null) return 0;
   
   if(root.left==null&&root.right==null) return 1;
if(root.left!=null)
res=Math.min(res,minDepth(root.left));
if(root.right!=null)
res=Math.min(res,minDepth(root.right));

   return res+1;
   

    }
}

完美二叉树的节点

迭代

class Solution {
    public int countNodes(TreeNode root) {
        int res=0;
    if(root==null) return res;
 
Queue<TreeNode> queue=new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
    int len=queue.size();
   
    while(len>0){
        TreeNode node=queue.poll();
        res++;
        len--;
        if(node.left!=null) queue.offer(node.left);
        if(node.right!=null) queue.offer(node.right);
    }
    
  
}
return res;
 
    }
}

递归

class Solution {
    public int countNodes(TreeNode root) {
   if(root==null) return 0;
   if(root.left==null&&root.right==null) return 1;

   int res=0;
   if(root.left!=null)
   res+=countNodes(root.left);
    if(root.right!=null)
   res+=countNodes(root.right);

   return res+1;
    }
}

平衡二叉树

递归

平衡二叉树的概念：左子树右子树的高度差不超过1

思路：

思路是对二叉树做后序遍历，从底至顶返回子树深度，若判定某子树不是平衡树则 “剪枝” ，直接向上返回。

class Solution {
    public boolean isBalanced(TreeNode root) {
       return Balance(root)!=-1; 
    }
    public int Balance(TreeNode root){
       if(root==null) return 0;
       if(root.left==null&&root.right==null) return 1;

        int left=Balance(root.left);
        if(left==-1) return -1;
        int right=Balance(root.right);
        if(right==-1) return -1;

        if(Math.abs(right-left)>1) 
        return -1;   
        
        return  Math.max(left,right)+1;
         }
        
    
}

另一种思路更好想到，但是没有第一种秒！！

class Solution {
    public boolean isBalanced(TreeNode root) {
       return Balance(root)!=-1; 
    }
    public int Balance(TreeNode root){
       if(root==null) return 0;
       if(root.left==null&&root.right==null) return 1;

        int left=Balance(root.left);
        if(left==-1) return -1;
        int right=Balance(root.right);
        if(right==-1) return -1;

        if(Math.abs(right-left)>1) 
        return -1;   
        
        return  Math.max(left,right)+1;
         }
        
    
}

二叉树的所有路径

迭代

257. 二叉树的所有路径 - 力扣（LeetCode）

根据栈“先入后出”的特点，结合前序遍历的顺序，迭代的过程也就出来了：

每次都是先将根节点放入栈，然后右子树，最后左子树。

            // 节点和路径出栈
            String path = (String) stack.pop();
            TreeNode node = (TreeNode) stack.pop();

这一步有回溯的思想 

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        // 初始化
        List<String> res = new ArrayList<>();
        if (root == null)
            return res;

        Stack<Object> stack = new Stack<>();
        stack.push(root);
        stack.push(root.val + "");

        while (!stack.isEmpty()) {
            // 节点和路径出栈
            String path = (String) stack.pop();
            TreeNode node = (TreeNode) stack.pop();
            // 如果当前节点为叶子节点
            if (node.left == null && node.right == null) {
                res.add(path);
            }
            // 右子树入栈
            if (node.right != null) {
                stack.push(node.right);
                stack.push(path + "->" + node.right.val);
            }
            // 左子树入栈
            if (node.left != null) {
                stack.push(node.left);
                stack.push(path + "->" + node.left.val);
            }
        }
        return res;
    }
}

递归

和字符串相关题目，把握String和StringBuilder

class Solution {
     List<String> res=new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
       String s="";
        deal(root,s);
        return res;

    }

    public void deal(TreeNode root,String s){
        if(root==null) return ;
        if(root.left==null&&root.right==null)
        res.add(new StringBuilder(s).append(root.val).toString());
        
        String temp=new StringBuilder(s).append(root.val).append("->").toString();
        deal(root.left,temp);
        deal(root.right,temp);
      
    }

}

左叶子之和

迭代

404. 左叶子之和 - 力扣（LeetCode）

public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) {
            return 0;
        }
        LinkedList<Pair<TreeNode, Boolean>> stack = new LinkedList<>();
        stack.push(new Pair<>(root, false));

        int sum = 0;
        Boolean flag;
        while (!stack.isEmpty()) {
            Pair<TreeNode, Boolean> pair = stack.pop();
            root = pair.getKey();
            flag = pair.getValue();
            if (flag && root.left == null && root.right == null) {
                sum += root.val;
            }
            if (root.left != null) {
                stack.push(new Pair<>(root.left, true));
            }
            if (root.right != null) {
                stack.push(new Pair<>(root.right, false));
            }
        }
        return sum;
    }

404. 左叶子之和 - 力扣（LeetCode）

利用BFS迭代

借助队列

// 层序遍历迭代法
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int sum = 0;
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size -- > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) { // 左节点不为空
                    queue.offer(node.left);
                    if (node.left.left == null && node.left.right == null){ // 左叶子节点
                        sum += node.left.val;
                    }
                }
                if (node.right != null) queue.offer(node.right);
            }
        }
        return sum;
    }
}

递归

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {

if(root==null)
return 0;
int left=sumOfLeftLeaves(root.left);
int right=sumOfLeftLeaves(root.right);

int leaf=0;
if(root.left!=null&&root.left.left==null&&root.left.right==null){
    leaf=root.left.val;
}

return leaf+left+right;
    }
}

找树左下角的值

迭代

使用 BFS 进行「层序遍历」，每次用当前层的首个节点来更新 ans，当 BFS 结束后，ans 存储的是最后一层最靠左的节点。

class Solution {
    public int findBottomLeftValue(TreeNode root) {
        Deque<TreeNode> d = new ArrayDeque<>();
        d.addLast(root);
        int ans = 0;
        while (!d.isEmpty()) {
            int sz = d.size();
            ans = d.peekFirst().val;
            while (sz-- > 0) {
                TreeNode poll = d.pollFirst();
                if (poll.left != null) d.addLast(poll.left);
                if (poll.right != null) d.addLast(poll.right);
            }
        }
        return ans;
    }
}

Deque <TreeNode> d = new ArrayDeque<>();
在Java中，`Deque` 接口是双端队列的接口，它继承自 `Queue` 接口。`Deque` 提供了在两端添加和移除元素的方法。

- `peekFirst()` 方法用于获取双端队列的第一个元素，但不移除它。
- `peekLast()` 方法用于获取双端队列的最后一个元素，也不移除它。

而 `peek()` 方法的行为取决于实现 `Deque` 接口的具体类。如果 `Deque` 实现是按照先进先出（FIFO）原则工作的，比如 `ArrayDeque`，那么 `peek()` 方法会返回第一个元素。如果 `Deque` 实现是按照后进先出（LIFO）原则工作的，比如 `LinkedList`，那么 `peek()` 方法会返回最后一个元素。

所以，`peek()` 方法取的是第一个元素还是最后一个元素，取决于 `Deque` 的具体实现。

递归

思路：

可以使用 DFS 进行树的遍历，每次优先 DFS 当前节点的左子树，每次第一次搜索到当前深度 depth 时，必然是当前深度的最左节点，此时用当前节点值来更新 ans。

class Solution {
    int max,ans;
    public int findBottomLeftValue(TreeNode root) {
        dfs(root,1);
        return ans;
    }

    public void dfs(TreeNode root,int depth){
        if(root==null) return ;
        if(depth>max){
            max=depth;
            ans=root.val;
        }
  
        dfs(root.left,depth+1);
        dfs(root.right,depth+1);
    }
  
}

路径总和

迭代

BFS

  class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
    // 如果根节点为空，直接返回false
    if (root == null) return false;
    // 创建一个队列，用于广度优先搜索（BFS）
    Deque<Pair<TreeNode, Integer>> queue = new LinkedList<>();
    // 将根节点和它的值作为一个对（Pair）添加到队列中
    queue.offer(new Pair<>(root, root.val));
    // 当队列不为空时，继续循环
    while (!queue.isEmpty()) {
        // 从队列中取出一个对
        Pair<TreeNode, Integer> pair = queue.poll();
        // 获取对中的节点和路径和
        TreeNode node = pair.getKey();
        int pathSum = pair.getValue();
        // 如果当前节点是叶子节点（即左右子节点都为空），并且路径和等于目标值，返回true
        if (node.left == null && node.right == null && pathSum == sum) {
            return true;
        }
        // 如果左子节点不为空，将左子节点和当前路径和加上左子节点的值作为一个对添加到队列中
        if (node.left != null) {
            queue.offer(new Pair<>(node.left, pathSum + node.left.val));
        }
        // 如果右子节点不为空，将右子节点和当前路径和加上右子节点的值作为一个对添加到队列中
        if (node.right != null) {
            queue.offer(new Pair<>(node.right, pathSum + node.right.val));
        }
    }
    // 如果遍历完所有节点都没有找到满足条件的路径，返回false
    return false;
}

递归

DFS

public class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if(root == null){
            return false;
        }
        if(root.left == null && root.right == null){
            return root.val == sum;
        }
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
        
    }
}

剩下的二叉树的题目明天再复盘，我感觉一次性那么多题目，我脑子都不想动了，就被动的看答案了

螺蛳粉一级爱好者
关注
专栏目录
代码随想录算法训练营（二叉树总结篇）
Ricardo的博客
08-15 358
int val;val=0;val=_val;1.涉及二叉树的问题，首先仔细审题，判断遍历顺序2.其次根据思路写出伪代码3.根据伪代码进行修改。
平衡二叉树总结
zxzxin的博客~
04-20 3829
目录 平衡二叉树相关概念以及性质 平衡二叉树的类结构 LL型失衡以及解决办法 RR型失衡以及解决办法 LR型失衡以及解决办法 RL型失衡以及解决办法 balance和checkBalance函数 完整源码测试 说明 在学二叉平衡树之前，可以先学一下二叉排序树。 在下面的源代码中，设计的二叉查找树的insert方法和remove方法，以及findMin()和findMa...
二叉树总结
weixin_39759634的博客
01-22 262
按照labuladong做了二叉树的题，在此稍微总结一下 1.二叉树的定义： python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right c++ struct TreeNode { int val; TreeNode
二叉树的总结
2301_81026736的博客
04-13 818
总结了我学习二叉树的知识点和个人理解
【数据结构导论之树和二叉树总结篇】
展翅的雄鹰
10-16 808
前言： 树是一类重要的数据结构，作为树形结构的代表，无论在自考的学习过程还是软考的学习过程中，我们都与之深之接触。今天，小编来总结一下树，此篇博文以数据结构导论第四章为参考，进行总结！希望给看博文的你带来收获！ 核心： 想一想，关于树？我们都涉及到了什么： 这个章节的标题为树和二叉树。里面的内容主要围绕树、森林和二叉树以及它们之间的关系来展开本章节的论述的！其中遍历、转换、
二叉树基础总结
2301_80841939的博客
02-14 2617
树（层级结构）是一种重要的非线性数据结构（递归的数据结构），它由n（n≥0）个有限节点组成一个具有层次关系的集合。这些节点具有如下特性：（在一个有效的树中，如果有n个节点，就会有n-1条边。每个节点有零个或多个子节点。没有父节点的节点称为根节点。根：树的最顶部的节点，唯一没有双亲的节点。每一个非根节点有且只有一个父节点。除了根节点外，每个子节点可以分为多个不相交的子树。树的术语结点：使用树结构存储的每一个数据元素都被称为“结点”。森林：多棵互不相交的树的集合称为森林。
二叉树基础篇
weixin_61196535的博客
06-28 615
了解二叉树基本概念，为后续做题打基础
代码随想录算法训练营第23天 |等二刷复习的时候 直接先看这篇 二叉树总结篇 669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树
lebowskii的博客
10-13 401
day 23天 二叉树篇章结束
总结篇：二叉树遍历
热门推荐
m0_61661179的博客
10-19 6万+
本文旨在于以通俗易懂地方式阐述二叉树遍历方法！
C++实现二叉树非递归遍历方法实例总结
09-04
总结来说，C++实现二叉树非递归遍历的关键在于理解遍历的顺序，并巧妙地利用栈来模拟递归过程。这种方法不仅适用于面试，而且在实际编程中也具有较高的效率和灵活性。通过熟练掌握这些技巧，可以更好地理解和解决与...
考研常考的二叉树相关算法总结（详细全面，PDF版）
11-16
本篇将详细介绍二叉树的基本概念、存储结构以及几种常见的遍历方法。 1. **二叉树的定义与链式存储结构** 二叉树是一种特殊的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。在链式存储结构中...
数据结构|二叉树基本篇
星空下的程序猿
09-11 292
二叉树 1 什么是树以及树的相关概念 树（Tree）是n（n>=0)个结点的有限集。n=0时称为空树。在任意一颗非空树中： 1）有且仅有一个特定的称为根（Root）的结点； 2）当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、…、Tn，其中每一个集合本身又是一棵树，并且称为根的子树。 此外，树的定义还需要强调以下两点： n>0时根结点是唯一的，不可能存...
21_动态规划与数据结构结合
刘炫320的博客
09-11 572
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 971
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 688
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 1092
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
数据结构 - 栈
最新发布
kaneki_lh的博客
09-13 501
/指向栈的指针int maxlen;//表示栈的最大长度int top;//栈顶元素的下标，用来指明栈顶的位置}s//数据域名//指针，指向栈下一个元素。
0基础跟德姆（dom）一起学AI Python进阶10-算法和数据结构
chrisfanallin的博客
09-11 1306
AI全流程带你玩 0基础带你学人工智能相关软件，讲解机器学习、深度学习、大模型等人工智能领域核心知识。 帮助想了解，或者正在AI赛道成长的你。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值