LeetCode二叉树篇题解,看这一篇就够了

最新推荐文章于 2022-09-18 23:33:43 发布
最新推荐文章于 2022-09-18 23:33:43 发布
阅读量212 收藏
点赞数
分类专栏： LeetCode刷题 文章标签： 二叉树 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bebirds/article/details/114642233
版权

LeetCode二叉树篇题解,看这一篇就够了

文章目录

基础知识

二叉树的基础知识参考

java中提供 Deque双端队列实现队列与栈的各种需求, 题目中经常会用到如下

  • offerlast(node)添加元素到队尾
  • offerFist(node)添加元素到队头
  • new LinkedList<>(deque), 利用双端队列新建列表
  • 以上三步可用 List 列表的 add(node) 尾插 , add(0,node)头插直接实现

树的三种遍历

  • 二叉搜索树的遍历共有四种, 即前序遍历、中序遍历、后序遍历、以及层序遍历、这四种遍历方式是 BST 的重中之重, 大部分树的题目都可以在这四种遍历的基础上修改得以解答. 所以我们必须牢记它们的写法.

  • 首先让我们通过三道题来了解 BST 的前序, 中序, 后序遍历, 同时,每种遍历又可以用递归和迭代两种方式实现, 最后我们还补充一个迭代的统一写法.

    94、二叉树的中序遍历

    144、二叉树的前序遍历

    145、二叉树的后序遍历

//树节点类定义
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {}
    TreeNode(int x) {
        val = x;
    }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
递归实现
List<Integer> list = new ArrayList<>();

//前序遍历
public void preorder(TreeNode root){
    if(root != null){
        list.add(root.val);
        preorder(root.left);
        preorder(root.right);
    }
}

//中序遍历
public void inorder(TreeNode root){
    if(root != null){
        inorder(root.left);
        list.add(root.val);
        inorder(root.right);
    }
}

//后序遍历
public void backorder(TreeNode root){
    if(root != null){
        backorder(root.left);
        backorder(root.right);
        list.add(root.val);
    }
}
栈迭代
//先序遍历
public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stk = new LinkedList<TreeNode>();
    while(root != null || !stk.isEmpty()){
        while(root != null){
            res.add(root.val);//先序和中序的差别就是这条语句的插入位置
            stk.push(root);
            root = root.left;
        }
        root = stk.pop();
        root = root.right;
    }
    return res;
}

//中序遍历
public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stk = new LinkedList<TreeNode>();
    while(root != null || !stk.isEmpty()){
        while(root != null){
            stk.push(root);
            root = root.left;
        }
        root = stk.pop();
        res.add(root.val);
        root = root.right;
    }
    return res;
}

//后序遍历
//与中序和前序的结构差别大,不便记忆
统一结构

  • 参考 颜色标记法

  • 实现了前中后序遍历的统一结构写法,只需改变节点的进栈顺序

public List<Integer> inorderTravelsal(TreeNode root){

    HashMap<TreeNode, Integer> map = new HashMap<>();
    List<Integer> res = new ArrayList<>();
    Deque<TreeNode> stack = new LinkedList<>();
    
    if(root == null)  //初始检查
    	return res;
    
    //根节点进栈
    stack.push(root);
    map.put(root,1); //1 表示第一次访问, 2 表示第二次访问
  
    while(!stack.isEmpty()){
        TreeNode node = stack.pop();
        
        if(1 == map.get(node)){
          
            //中序遍历,因为栈的特点,先进后出,右-中-左进栈, 出栈时就是 左-中-右
            if(node.right != null){
                stack.push(node.right);
                map.put(node.right,1);
            } 
            stack.push(node);
            map.put(node,2);
            if(node.left != null){
                stack.push(node.left);
                map.put(node.left,1);
            }
                
            //前序遍历
            if(node.right != null){
                stack.push(node.right);
                map.put(node.right,1);
            } 
            if(node.left != null){
                stack.push(node.left);
                map.put(node.left,1);
            }
            stack.push(node);
            map.put(node,2);
          
            //后序遍历
            stack.push(node);
            map.put(node,2);
						if(node.right != null){
                stack.push(node.right);
                map.put(node.right,1);
            } 
            if(node.left != null){
                stack.push(node.left);
                map.put(node.left,1);
            } 
        }else{
            res.add(node.val);
        }
    }
    return res;
}
层序遍历
  • 层序遍历也就是我们经常所说的广度优先遍历 (BFS)

LeetCode——102、二叉树的层序遍历

LeetCode——107、二叉树的层序遍历 2

public class Tree_102_107 {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> lists = new ArrayList<>();
        if(root == null)
            return lists ;
        //核心数据结构 : 队列
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        //while 循环每一层
        while(!q.isEmpty()){
            int sz = q.size();
            List<Integer> list = new ArrayList<>();
          	//for 循环对当前层进行操作,同时将下一层入队
            for(int i = 0 ; i < sz ; ++i){
              	//出队操作在for 循环内,容易写到外面导致出错
                TreeNode node = q.poll();
                list.add(node.val);
                if(node.left != null)
                    q.offer(node.left);
                if(node.right != null)
                    q.offer(node.right);
            }
            lists.add(list);
            //leetcode_107
            //lists.add(0,list); //lists.add(0,list) 头插 🌟
        }
        return lists;
    }
}

判断 BST

  • 学会四种遍历方式后, 先让我们看看如何通过中序遍历的方式判断一个树是否为一个有效的二叉搜索树
  • 有效的二叉树即中序遍历为升序, 这里我们利用栈的特性进行判断, 从而省去构建好后在判断的时间.

LeetCode——98、验证二叉搜索树

public class IsValidBST_98 {
    public boolean isValidBST(TreeNode root) {
        double inorder = -Double.MAX_VALUE;
        Stack<TreeNode> stack = new Stack<>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            // 如果中序遍历得到的节点的值小于等于前一个 inorder，说明不是二叉搜索树
            if (root.val <= inorder)
                return false;
            inorder = root.val;
            root = root.right;
        }
        return true;
    }
}

构建 BST

  • 现在我们能判断 BST了, 但是如何构建一棵 BST 呢? 如何构建多棵不一样的 BST 呢?

题目: 给定 n , 构建一棵从 1…n 的树

public class BinaryTree {
    public TreeNode createBinaryTree(int n){
        return helper(1,n);
    }
    //构建一颗平衡二叉树
    public TreeNode helper(int start, int end){
        if(start > end){
            return null;
        }
        int i = (start + end) / 2;
        TreeNode root = new TreeNode(i);
        root.left = helper(start, i -1);
        root.right = helper(i + 1, end);
        return root;
    }
}

public class GenerateTrees_95 {
    public List<TreeNode> generateTrees(int n){
        if(n == 0)
            return new LinkedList<TreeNode>();
        return generateTrees(1,n);
    }
    public List<TreeNode> generateTrees(int start, int end){
        List<TreeNode> allTrees = new LinkedList<>();
        //结束条件
        if(start > end){
          	//必须添加一个空元素,不然下面枚举会出错
          	//比如 leftTrees = null , 则不会进第一层for循环,导致要走的二层for循环无法进行
          	//但是添加了一个空元素后, leftTree = [null], 是含有一个空元素的,二者的意思不同
            allTrees.add(null);
            return allTrees;
        }
        //枚举可行根节点
        for(int i = start ; i <= end ; i++){
            //获取所有可行的左子树集合
            List<TreeNode> leftTrees = generateTrees(start, i - 1);
            List<TreeNode> rightTrees = generateTrees(i+1,end);

            //从左子树集合中选出一个左子树，从右子树集合中选出一颗右子树，拼接到根节点上
            for(TreeNode left : leftTrees){
                for(TreeNode right : rightTrees){
                    TreeNode currTree = new TreeNode(i);
                    currTree.left = left;
                    currTree.right = right;
                    allTrees.add(currTree);
                }
            }
        }
        return allTrees;
    }
}

还原树(LeetCode——105,106)

  • 利用前序遍历和中序遍历还原树
  • **重要程度:**🌟🌟🌟🌟
  • 解题关键: 确定每次左右子树递归的界限, 通过HashMap存储中序遍历的值和下标, 实现 O ( 1 ) O(1) O(1)的查找复杂度, 并以此计算得到左右子树的长度, 从而得到下标.
  • 中序遍历和后序遍历还原树, 只需要改变一下结束条件和递归的下标值就行.

在这里插入图片描述

import java.util.HashMap;
import java.util.Map;

public class Tree_105 {

    private Map<Integer, Integer> indexMap;

    public TreeNode buildTree(int[] preorder, int[] inorder){
        int n = preorder.length;
        indexMap = new HashMap<Integer, Integer>();
        for(int i = 0 ; i < n ; i++){
            indexMap.put(inorder[i],i);
        }
        return myBuildTree(preorder, inorder, 0,n-1,0,n-1);
    }

    public TreeNode myBuildTree(int[] preorder, int[] inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right){
        //前序和中序遍历还原树的结束条件
      	if(preorder_left > preorder_right){
            return null;
        }

        //前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        //中序遍历中定位根节点
        int inorder_root = indexMap.get(preorder[preorder_root]);

        //先把根节点建立出来
        TreeNode root = new TreeNode(preorder[preorder_root]);
        //得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;

        //递归地构造左子树， 并连接到根节点
        root.left = myBuildTree(preorder, inorder , preorder_left + 1 , preorder_left + size_left_subtree , inorder_left , inorder_root - 1);
        root.right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);

        return root;
    }
}

平衡二叉树

  • 判断一棵树是否是平衡二叉树
  • **难度:**自底向上思想——🌟🌟🌟
  • 平衡二叉树定义: 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1
  • 当遇到重复计算问题时, 可以考虑反方向思考, 一般自底向上优于自顶向下
//自顶向下，双重递归，重复计算，时间复杂度高
public boolean isBalanced(TreeNode root) {
    if(root == null)
        return true;
    else
        return Math.abs(getLength(root.left)-getLength(root.right))<=1
        && isBalanced(root.left) && isBalanced(root.right);
}
public int getLength(TreeNode root){
    if(root == null)
        return 0;
    return Math.max(getLength(root.left),getLength(root.right)) + 1;
}

//自底向上,类似后序遍历
public boolean isBalanced2(TreeNode root){
    return height(root) >= 0;
}
public int height(TreeNode root){
    if(root == null){
        return 0;
    }
    int leftHeight ;
    int rightHeight ;
  	//将递归放入判断逻辑中, 达到剪枝的效果, 如果左子树不平衡则不用递归右子树
    if((leftHeight = height(root.left)) == -1 || (rightHeight = height(root.right)) == -1 
       || Math.abs(leftHeight - rightHeight) > 1)
        return -1;
    else
        return Math.max(leftHeight,rightHeight) + 1;
}

二叉树的路径问题

  • 接下来让我们来看看二叉树的路径问题

LeetCode——112、路径总和

LeetCode——129、求根节点到叶节点数字之和

  • 112判断是否存在路径

  • 129所有路径和相加

  • 二叉树的路径数即叶子节点数, 可以采用 BFS 和 DFS 两种方法求解, 个人推荐 BFS

  • 使用 BFS 我们只需一个队列层序遍历从上到下更新路径和, 到叶子节点出进行处理即可

  • 两题使用层序遍历的解法核心可以说几乎相同, 只需修改一下处理逻辑即可

//112、路径总和, BFS
public boolean hasPathSum(TreeNode root, int sum) {
    if(root == null){
        return false;
    }
    //一个队列存储节点
    Queue<TreeNode> queNode = new LinkedList<>();
    //一个队列存储值，更新到最后只剩下每一个叶子节点的对应的路径总和
    Queue<Integer> queVal = new LinkedList<>();
    queNode.offer(root);
    queVal.offer(root.val);
    while(!queNode.isEmpty()){
        TreeNode now = queNode.poll();
        int temp = queVal.poll();
        //叶节点处进行判断
        if(now.left == null && now.right == null){
            if(temp == sum){
                return true;
            }
            continue;
        }
        //
        if(now.left != null){
            queNode.offer(now.left);
            queVal.offer(now.left.val + temp);
        }
        if(now.right != null){
            queNode.offer(now.right);
            queVal.offer(now.right.val + temp);
        }
    }
    return false;
}

//129、所有路径和、BFS
public static int sumNumbers(TreeNode root) {
    if (root == null) {
        return 0;
    }
    Queue<Integer> sum = new LinkedList<>();
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    sum.offer(root.val);
    int sumAll = 0;
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        int num = sum.poll();
        if (node.left == null && node.right == null) {
            sumAll += num;
        } else {
            if (node.left != null) {
                queue.offer(node.left);
                sum.offer(num * 10 + node.left.val);
            }
            if (node.right != null) {
                queue.offer(node.right);
                sum.offer(num * 10 + node.right.val);
            }
        }
    }
    return sumAll;
}

LeetCode——113、路径总和 2

public class Tree_113 {
    List<List<Integer>> ret = new LinkedList<>();
    Deque<Integer> path = new LinkedList<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        dfs(root, sum);
        return ret;
    }
    public void dfs(TreeNode root, int sum){
        if(root == null){
            return ;
        }
        path.offerLast(root.val);
        sum -= root.val;
        if(root.left == null && root.right == null && sum == 0)
            ret.add(new LinkedList<Integer>(path));
        dfs(root.left, sum);
        dfs(root.right, sum);
        path.pollLast();
    }
}

其他

LeetCode——117、填充每个节点的下一个右侧节点指针 2

  • 本题与 116 题相同, 只是要求空间只能使用常数级
//树节点定义
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}

//利用层序遍历, 通过巧妙利用哑节点, 把每一层连接成一个链表
public Node connect(Node root) {
    if(root == null)
        return root;
    Node cur = root;
    while(cur != null){
        Node dummy = new Node(0);
        Node pre = dummy;
        while(cur != null){
            if(cur.left != null){
                pre.next = cur.left;
                pre = pre.next;
            }
            if(cur.right != null){
                pre.next = cur.right;
                pre = pre.next;
            }
            cur = cur.next;
        }
        cur = dummy.next;
    }
    return root;
}

LeetCode——173、二叉搜索树迭代器

  • 自定义了树迭代器 iterator 的写法
class BSTIterator {
    ArrayList<Integer> list;
    int index = -1;
    public BSTIterator(TreeNode root) {
        list = new ArrayList<>();
        dfs(root);
    }
    public void dfs(TreeNode root){
        if(root != null){
            dfs(root.left);
            list.add(root.val);
            dfs(root.right);
        }
    }
    public int next() {
        index += 1;
        return list.get(index);
    }
    public boolean hasNext() {
        return index + 1 < list.size();
    }
}

以上就是 leetcode 前两百道题树标签的题目汇总, 可以看出, 基本都逃不出四种遍历的框架, 所以重点记忆四种遍历框架, 多加练习, 树你就掌握啦!!

三金的代码时光
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列(Queue)
jakelihua
10-11 170
本文从题目出发，带领大家快速入门，Java中的自带API，Queue的使用。
leetcode二叉树
qq_43283527的博客
04-08 493
树的属性： 层次结构 一个节点的所有子节点独立于另一个节点的子节点。 二叉树：如果树中的每个节点最多有两个子节点，我们说该树是一个二叉树。 1.列表表示的树 在列表树的列表中，将根节点的值存储为列表的第一个元素；第二个元素：一个表示左子树的列表；第三个元素：表示右子树的另一个列表。 2.节点表示 用left 和right 的属性表示其他实例的引用。 3 . 树的遍历 前序：首先访问根节点，然...
【LeetCode】-二叉树
银尘博客
03-15 7660
文章目录前言一、二叉树的层序遍历 前言 初识LeetCode与算法，将在此系列文章里面，记录自己的算法学习经历，前期主要是监督自己学习打卡，后期我会将自己对知识的理解，慢慢补充到文章当中，希望大家能在阅读我的文章中，有所收获。该系列文章的刷题顺序以代码随想录为线索。 一、二叉树的层序遍历 题目： 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[1
LeetCode二叉树问题全解析（上）
qq_59539549的博客
03-09 1459
一、前言 二叉树的定义：二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分 在解决二叉树问题时，我们的利器就是“递归”，但是递归这种思想掌握起来常常让大家叫苦不迭，本篇文章将从易到难，深入浅出地讲解二叉树问题 对于二叉树，我们首先要了解几个最基本的公式： 1.若规定根节点的层数为1，则层数
LeetCode题目——二叉树篇
Pcl2001的博客
03-07 1506
LeetCode题目——二叉树篇前言一、二叉树的前、中、后序遍历1.前序遍历递归实现迭代法2.中序遍历递归迭代法3.后序遍历递归迭代二、二叉树的层次遍历三、二叉树的右视图四、二叉树的层平均值五、N叉树的层序遍历六、在每个树行中找最大值七、填充每个节点的下一个右侧节点指针（完全二叉树）八、填充每个节点的下一个右侧节点指针（普通二叉树）九、完全二叉树的节点个数![在这里插入图片描述](https://img-blog.csdnimg.cn/4ecfb9528fd44f388c1126f89885dd36.png
js-leetcode题解之验证平衡二叉树-题解.zip
最新发布
05-09
js js_leetcode题解之验证平衡二叉树_题解
leetcode分类-Leetcode:Leetcode题解
06-30
Leetcode代码题解 随缘刷题，选择性更新题解 LeetCode 94 144 145 二叉树的前中后序遍历： Leetcode 128 longest-consecutive-sequence 最长连续序列： Leetcode 155 Min Stack 最小栈： LeetCode 773 滑动谜题： .....
python-leetcode面试题解之第110题平衡二叉树-题解.zip
04-29
python python_leetcode面试题解之第110题平衡二叉树_题解
python-leetcode面试题解之第101题对称二叉树-题解.zip
04-29
python python_leetcode面试题解之第101题对称二叉树_题解
python-leetcode面试题解之对称二叉树.zip
03-06
python python_leetcode面试题解之对称二叉树
LeetCode二叉树问题全解析（中）
qq_59539549的博客
03-12 1839
一、二叉树的修改与改造问题 1、翻转二叉树 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。 这道题目大家第一次做可能会觉得它很简单，左换右，一直递归不就行了 但如果沉下心来思考这道问题的本质 我相信大家一定有所收获！ 之前我们介绍了各种遍历二叉树的方式，如果要翻转这颗二叉树 我们应该采取哪一种遍历方式呢？ 其实这道题采用前，中，后都可以 只要在遍历时交换左右节点即可 但是中序的时候有些麻烦 因为 我们左子树的节点已经完成了翻转而此时左右交换，中序遍历恰好需要到右子树.
LeetCode-104. 二叉树的最大深度_JavaScript
weixin_45344430的博客
08-06 300
给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度 3 。 程序代码 /** * Definition for a binary tree node. * function TreeNode(val, left, right) { * ..
Leetcode -二叉树
yuetan的博客
09-18 808
Leetcode
括号表示法字符串构造二叉树_一文带你看懂二叉树的序列化
weixin_39550379的博客
11-21 792
我们先来看下什么是序列化，以下定义来自维基百科：❝ 序列化（serialization）在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程...
Leetcode刷题总结——二叉树
weixin_47883447的博客
04-06 388
二叉树节点的定义： 1、二叉树的遍历 前序遍历（中左右）、中序遍历（左中右）、后序遍历（左右中） 递归三要素： 1）确定递归函数的参数和返回值：确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。 2）确定终止条件：写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。 3）.
LeetCode二叉树基础题（不断更新）
宗越的博客
08-29 382
107.Binary Tree Level Order Traversal II题意： 给定一个二叉树，由下而上、由左向右遍历其节点值并存储进一个二维vector里。思路： 广度优先遍历，最后再将二维vector颠倒即可。每遍历一层将该层的所有孩子节点放进队列里，放进去的的节点恰好是下一层节点总数，以此辨识节点所属层数。/** * Definition for a binary tree no
二叉树的存储结构
Here_的博客
10-09 221
二叉树的顺序存储 完全二叉树 这个是在完全二叉树中，什么是完全二叉树呢？简单就是结点的编号要和满二叉树的编号一一对应。 非完全二叉树： 补成完全二叉树，然后在补入的结点位置放入0； 二叉树的链式存储 data存入数据，再声明两个指针 ...
leetcode二叉树相关操作的总结
ss654271961的博客
08-09 765
做了这么多关于二叉树的题，发现一些题目的本质来来回回就是那些操作，所以觉得需要进行总结，可以让之后的思路更明晰。 二叉树的操作，最普遍的就是递归，和前中后序遍历，层序遍历。前中后序遍历可以用递归也可以用自己的栈代替递归栈。层序遍历用一个队列辅助，每一层都是上一层所有节点的孩子。在这个过程中也可以记录每一层包含的节点及个数。 递归的解决问题的话，有三个要素：首先你要确定他们之间有递归关系，大规模
Leetcode题目总结（二）——二叉树（20200924）
WallE
09-21 247
1、把二叉搜索树转换为累加树 （1）题目 给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。 例如： 输入: 原始二叉搜索树: 5 / \ 2 13 输出: 转换为累加树: 18 / \ 20 13 来源：力扣（Le...
leetcode 二叉树
09-16
在LeetCode上，二叉树问题是常见的算法题型，我们需要实现各种操作，如合并树、找出深度、遍历等。 在引用中，给出了一个合并二叉树的解法。该解法使用递归的方式将两棵二叉树合并为一棵新的二叉树。首先判断两棵树...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值