二叉树(JAVA)

最新推荐文章于 2024-04-27 18:02:39 发布
最新推荐文章于 2024-04-27 18:02:39 发布
阅读量216 收藏 2
点赞数
分类专栏： 数据结构和算法 文章标签： 二叉树 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bestandw1shes_lsy/article/details/112986373
版权

二叉树

前情提要

为什么需要树这种数据结构？
 
我们通过对比数组、链表、树的优缺点来进行分析，分析如下：
 
（1） 数组存储方式的分析：
 
        1）优点：通过下标方式访问元素，速度快；对于有序数组，还可使用二分查找提高检索速度；
 
        2）缺点：如果要删除具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 。
 
（2）链式存储方式的分析：
 
       1）优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)；
 
       2）缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 。
 
（3）树存储方式的分析：
 
        能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)， 既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度 。
 

1.二叉树的介绍

（1）树的常用术语

     1) 节点；

     2) 根节点；

     3) 父节点；

     4) 子节点；

     5) 叶子节点 (没有子节点的节点)；

     6) 节点的权(节点值)；

     7) 路径(从 root 节点找到该节点的路线)；

     8) 层；

     9) 子树；

    10) 树的高度(最大层数)；

    11) 森林 :多颗子树构成森林。

如下图所示：

（2）二叉树的概念

     1) 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树；

     2) 二叉树的子节点分为左节点和右节点 ；

        二叉树图示如下：

     3) 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则称为满二叉树；

       满二叉树图示如下：

     4) 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

        完全二叉树图示如下：

    如果去掉权值为1的节点，该树就不是完全二叉树了

2.二叉树-遍历

（1）二叉树的遍历有三种方式：

      1）前序遍历: 先输出父节点，再遍历左子树和右子树；

      2）中序遍历: 先遍历左子树，再输出父节点，再遍历右子树；

      3）后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点。

小结：看输出父节点的顺序，就确定是前序，中序还是后序

（2）实现逻辑：

       1）前序遍历：

            1.1）先输出当前节点（初始的时候是root节点）；

            1.2）如果左子节点不为空，则递归继续前序遍历；

            1.3）如果右子节点不为空，则递归继续前序遍历。 

       2）中序遍历：

            1.1）如果左子节点不为空，则递归继续中序遍历；

            1.2）再输出当前节点；

            1.3）如果右子节点不为空，则递归继续中序遍历。 

       3）后序遍历：

            1.1）如果左子节点不为空，则递归继续后序遍历；

            1.2）如果右子节点不为空，则递归继续后序遍历。 

            1.3）最后输出当前节点；

如下图所示：

3.二叉树-查找指定节点

（1）查找指定节点按照前、中、后序遍历的方式可以分为前序查找、中序查找、后续查找。

（2）实现逻辑：

        1）前序查找：

           1.1）先判断当前节点的是否是要查找的节点；

           1.2）如果是，则返回当前节点；

           1.3）如果不是，则判断当前节点的左节点是否为空，如果不为空，则继续向左递归前序查找；

           1.4）如果左递归前序查找，找到节点直接返回，否则继续判断当前的节点的右子节点是否为空，如果不为空，则继续向右递归前序遍历，如果还没找到，返回空。

           如下图所示：

        2）中序查找：

           1.1）判断当前节点的左节点是否为空，如果不为空，则继续向左递归中序查找，找到直接返回；

           1.2）如果没找到，则判断当前节点的是否是要查找的节点；

           1.3）如果当前节点是，直接返回；

           1.4）如果不是，则继续判断当前的节点的右子节点是否为空，如果不为空，则继续向右递归中序遍历，如果还没找到，返回空。

           如下图所示：

        3）后序查找：

           1.1）判断当前的节点的左子节点是否为空，如果不为空，则继续向左递归后序遍历，找到直接返回；

           1.2）如果没找到，则继续判断当前节点的右子节点是否为空，如果不为空，则继续向右递归后序遍历，找到直接返回；

           1.3）如果都没找到，则和当前节点比较，如果是，返回当前节点，否则返回空。

           如下图所示：

3.二叉树-删除节点

为了简单的讲解删除功能，所以该次删除做了特别的要求，如下：

（1）如果删除的节点是叶子节点，则删除该节点；

（2）如果删除的节点是非叶子节点，则删除该子树。

如果要了解具体的删除功能，在 二叉排序树 中有详细说明。

 

实现逻辑：

首先考虑如果树只有一个root节点，且该节点是需要删除的值，直接将树置空即可；

（1）因为二叉树是单向的，所以需要判断当前节点的子节点是否是需要删除的节点，而不能去判断当前这个节点是不是需要删除的节点；

（2）如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，就将当前节点的左子节点置空，并且直接返回，结束递归；

（3）如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，就将当前节点的右子节点置空，并且直接返回，结束递归；

（4）如果第2步和第3步没有删除节点，那么就需要向左子树进行递归删除；

（5）如果第4步也没有删除节点，那么就需要向右子树进行递归删除。

 

4.二叉树代码实现

public class BinaryTreeDemo {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);

        System.out.println("前序遍历:"); // 1,2,3,5,4
        binaryTree.preOrder();
        System.out.println("------------------------------");
        System.out.println("中序遍历:"); // 2,1,5,3,4
        binaryTree.infixOrder();
        System.out.println("------------------------------");
        System.out.println("后序遍历:"); // 2,5,4,3,1
        binaryTree.postOrder();
        System.out.println("------------------------------");
        // 前序查找
        System.out.println("前序查找:");
        HeroNode resNode = binaryTree.preOrderSearch(5);
        if (resNode != null) {
            System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
        }else {
            System.out.printf("没有找到 no = %d 的英雄", 5);
        }

        System.out.println();
        System.out.println("------------------------------");
        // 中序查找
        System.out.println("中序查找:");
        resNode = binaryTree.infixOrderSearch(5);
        if (resNode != null) {
            System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
        }else {
            System.out.printf("没有找到 no = %d 的英雄", 5);
        }

        System.out.println();
        System.out.println("------------------------------");
        // 后序查找
        System.out.println("后序查找:");
        resNode = binaryTree.postOrderSearch(5);
        if (resNode != null) {
            System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
        }else {
            System.out.printf("没有找到 no = %d 的英雄", 5);
        }
        System.out.println();
        System.out.println("------------------------------");
        System.out.println("删除前,前序遍历");
        binaryTree.preOrder(); // 1,2,3,5,4
        binaryTree.delNode(5);
        // binaryTree.delNode(3);
        System.out.println("删除后，前序遍历");
        binaryTree.preOrder();
    }
}

// 定义 BinaryTree 二叉树
class BinaryTree {

    private HeroNode root;

    public HeroNode getRoot() {
        return root;
    }

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    // 前序遍历
    public void preOrder() {
        if (root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 后序遍历
    public void postOrder() {
        if (root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 前序查找
    public HeroNode preOrderSearch(int no){
        if (root != null){
            return root.preOrderSerach(no);
        }else {
            return null;
        }
    }

    // 中序查找
    public HeroNode infixOrderSearch(int no){
        if (root != null){
            return root.infixOrderSearch(no);
        }else {
            return null;
        }
    }

    // 后序查找
    public HeroNode postOrderSearch(int no){
        if (root != null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }

    // 删除结点
    public void delNode(int no){
        if (root != null){
            // 如果只有一个 root 结点, 这里立即判断 root 是不是就是要删除结点
            if (root.getNo() == no){
                root = null;
            }else {
                //递归删除
                root.delNode(no);
            }
        }else{
            System.out.println("空树，不能删除~");
        }
    }
}

// 创建 HeroNode 结点
class HeroNode {

    private int no;
    private String name;
    private HeroNode left;  // 默认 null
    private HeroNode right; // 默认 null

    public HeroNode(int no, String naem) {
        this.no = no;
        this.name = naem;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    // 前序遍历
    public void preOrder() {
        // 先输出父结点
        System.out.println(this);
        // 再递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 最后递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    // 中序遍历
    public void infixOrder() {
        // 先递归向左子树前序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 再输出父结点
        System.out.println(this);
        // 最后递归向右子树前序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    // 后序遍历
    public void postOrder() {
        // 先递归向左子树前序遍历
        if (this.left != null) {
            this.left.postOrder();
        }
        // 然后递归向右子树前序遍历
        if (this.right != null) {
            this.right.postOrder();
        }
        // 最后再输出父结点
        System.out.println(this);
    }

    // 前序查找
    public HeroNode preOrderSerach(int no){
        System.out.println("进入前序遍历");
        // 1.判断当前节点的no是否等于要查找的,如果等于就返回当前节点
        if (this.no == no){
            return this;
        }
        // 2.如果不等于，则判断当前节点的左节点是否为空，如果不为空，则递归前序查找
        HeroNode node = null;
        if (this.left != null){
            node = this.left.preOrderSerach(no);
        }
        // 3.如果左递归前序查找，找到节点则返回，否则继续判断当前节点的右节点是否为空，如果不为空，则继续递归前序查找
        if (node != null){
            return node;
        }
        if (this.right != null){
            node = this.right.preOrderSerach(no);
        }
        return node;
    }

    // 中序查找
    public HeroNode infixOrderSearch(int no){
        // 1.判断当前节点的左节点是否为空，如果不为空，则递归前序查找
        HeroNode node = null;
        if (this.left != null){
            node = this.left.infixOrderSearch(no);
        }
        // 2.如果左递归前序查找，找到节点则返回，否则判断当前节点的no是否等于要查找的,如果等于就返回当前节点
        if (node != null){
            return node;
        }
        System.out.println("进入中序遍历");
        if (this.no == no){
            return this;
        }
        // 3.如果不等于，继续判断当前节点的右节点是否为空，如果不为空，则继续递归前序查找
        if (this.right != null){
            node = this.right.infixOrderSearch(no);
        }
        return node;
    }

    // 后序查找
    public HeroNode postOrderSearch(int no) {
        // 1.判断当前节点的左节点是否为空，如果不为空，则递归前序查找
        HeroNode node = null;
        if (this.left != null){
            node = this.left.postOrderSearch(no);
        }
        // 2.如果左递归前序查找，找到节点则返回，否则继续判断当前节点的右节点是否为空，如果不为空，则继续递归前序查找
        if (node != null){
            return node;
        }
        if (this.right != null){
            node = this.right.postOrderSearch(no);
        }
        if (node != null){
            return node;
        }
        System.out.println("进入后序遍历");
        // 3.如果不等于，则判断当前节点的no是否等于要查找的,如果等于就返回当前节点
        if (this.no == no){
            return this;
        }
        return node;
    }

    // 删除结点
    // 1.如果删除的节点是叶子节点，则删除该节点
    // 2.如果删除的节点是非叶子节点，则删除该子树
    public void delNode(int no){
        // 1.因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断 当前这个结点是不是需要删除结点.
        // 2.如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将 this.left = null; 并且就返回 (结束递归删除)
        if (this.left != null && this.left.no == no){
            this.left = null;
            return;
        }
        // 3.如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将 this.right= null ;并且就返回 (结束递归删除)
        if (this.right != null && this.right.no == no){
            this.right = null;
            return;
        }
        // 4.如果第 2 和第 3 步没有删除结点，那么我们就需要向左子树进行递归删除
        if (this.left != null){
            this.left.delNode(no);
        }
        // 5.如果第 4 步也没有删除结点，则应当向右子树进行递归删除.
        if (this.right != null){
            this.right.delNode(no);
        }
    }

}

 

BestandW1shEs
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
erchashu.rar_二叉树 java
09-24
利用java 实现 二叉树算法，自己编写的利用java 实现 二叉树算法
数据结构（二叉树）——Java实现
m0_56911284的博客
11-03 2651
认识二叉树，并用Java实现其一系列的操作。
二叉树（Java实现）
热门推荐
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
算法学习———二叉树（Java版）
Sencq的博客
10-23 898
本周leetcode刷题路线：二叉树算法题常用方法：递归算法 递归算法基本思路：只考虑部分，不考虑整体；101. 对称二叉树（简单）： 题目描述： 给你一个二叉树的根节点 ， 检查它是否轴对称。 示例： 输入：root = [1, 2, 2, 3, 4, 4, 3] 输出：true 解题思路： 检查该二叉树是否为对称二叉树，即检查该二叉树根节点的左子树翻转后是否与右子树相等（226.
红黑树 一看就会
杨
09-16 193
red-black tree是自平衡 (非绝对平衡) 的二叉查找树! 先尝试recolor，(置色红黑) 再尝试rotation；(旋转) 插入新节点，标红，如果为根节点，则标黑； 如果不是根节点，且其parent是红，uncle是红： { 1.将parent和uncle同时标黑； 2.将grand parent标红； 3.新节点标红；(让新节点的颜色与其grand parent颜色一致) } 插入新节点，标红，如果为根节点，则标黑； 如果不是根节点，且其parent是红，uncle是黑： { 1.左左
Java中判断对象是否为空的方法详解
恋上、小幸福的博客
07-19 1万+
在Java编程中，经常会遇到判断对象是否为空的情况。空指针异常是常见的程序错误之一，因此在编码过程中，判断对象是否为空是一个重要的防御措施。本篇博客将深入探讨Java中判断对象是否为空的不同方法，包括使用条件判断、使用Java 8的Optional类、使用Apache Commons Lang库等，通过详细的解释和举例说明，帮助读者正确处理空对象问题。
Java语言----二叉树
tq02的博客
05-28 2684
二叉树详细讲解，以及Java实现代码
【Java】二叉树
qq_44544908的博客
02-13 485
题解：将该二叉树节点缩小100倍，变为该完全二叉树中总共有10个节点，由性质2可得深度K为：4，前三层共有7个节点，则最后一层有10-7=3个节点，由性质1的第三层有4个节点，其中有2个节点上面有子节点，剩余2个为叶子结点，则该二叉树共有3+2=5个叶子结点，扩大100倍为500个叶子结点，则剩余的就位非叶子结点。如：假设一棵完全二叉树中总共有1000个节点，则该二叉树中__500___个叶子节点，__500___个非叶子节点，__1___个节点只有左孩子，__0___个只有右孩子。代表根节点的左子树，
二叉树（Java版）
WYSCODER的博客
08-04 2719
二叉树，看这一篇就够了~~~
【数据结构】之二叉树的java实现
dawuafang
10-02 517
二叉树的定义： 二叉树是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树的形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。 二叉树(BinaryTree)是n(n≥0)个结点的有限集，它或者是空集(n=0)，或者由一个根结点及两棵互不相交的、分别称作这个根的左子树和右子树的二叉树组成。 这个定义是递归的。由于左...
数据结构-二叉树 JAVA语言实现
10-16
使用教程：http://blog.csdn.net/z740852294/article/details/78250911
二叉树java代码
01-22
java作业中的二叉树代码。在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 一棵深度为...
二叉树java实现
08-27
二叉树基本操作java实现，递归与非递归实现三种遍历顺序，对应的我的博客地址是： http://blog.csdn.net/u012320459/article/details/48025767#t8
【数据结构】三、栈和队列：2.顺序栈&共享栈（顺序栈的初始化，判空，进栈，出栈，读取栈顶，顺序栈实例）
来csdn只办三件事：开源！开源！还是***开源！
04-23 1145
因为顺序栈的缺点是栈的大小不可变，所以引出共享栈，两个栈共享一片空间。这片存储空间不单独属于任何一个栈，某个栈需要的多一点，它就可能得到更多的存储空间。两个栈的栈底在这片存储空间的两端，当元素入栈时，两个栈的栈顶指针相向而行。当他们下一个指针的位置在一起时，说明这个栈已经放满元素。C++是一门面向对象的高级语言，在我们编写代码中，常常离不开对对象的创建和清理对象资源。指向栈顶元素，一般存储的是数组的下标。top当前指向的位置是栈顶上面的一个没有元素的空位置。如果有abcde，5个元素，那么满栈top=4。
【Redis 开发】(Feed流的模式，GEO数据结构，BitMap,HyperLogLog)
最新发布
weixin_62513677的博客
04-27 565
如果我们需要统计UV值，我们可以使用HyperLogLog，它是从LogLog算法中派生出来的概率算法，用于确定非常大的集合的基数，但是它的单个存储的统计内存永远小于16kb，但是代价就是统计是概率性的有小于0.81%的误差，不过可以忽略。也叫做写扩散，发布的消息不需要写入到发件箱中，直接推送到被关注人的收件箱中并通过时间戳进行排序，延时低，但是比如说微博中的一些大V，粉丝人特别多，这样就会写很多。范围可以是圆形或矩形。:指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。
数据结构中的串（String）：概念、操作和实际应用
JAZJD的博客
04-24 937
在计算机科学中，串 是由零个或多个字符组成的有限序列，是数据结构中常见的一种基本类型。它可以为空串，也可以是由字符组成的非空串。串通常用于表示文本数据，如文件内容、用户输入等，因此在算法和程序设计中占据着重要的地位。一个串可以是由字母、数字、符号等任意字符组成，字符的种类和个数没有固定限制。例如，"Hello, World!@#$%" 都是串的例子。串的重要性在于它是对文本数据进行处理和操作的基础，涉及字符串匹配、文本编辑、编译器设计等多个领域。因此，深入理解串的特性和操作对于程序设计人员至关重要。
数据结构-树和森林之间的转化
2302_80729149的博客
04-23 338
这里我们根据左儿子右爸爸的逻辑将每个子树转化为二叉树的形式，对于第一个树，b，c，d都是a的儿子，所以都放到a的左边，而bcd之间也是兄弟关系，一起放到右边，然后再将三个树转化完毕后依次相连，构成二叉树的形式。从树的二叉链表的定义可知，任何一棵和树对应的二叉树，其根节点的右子树必为空。这里我们举三个树，将这个由三个树组成的森林组成二叉树是这个样子的。下面我们说明一下详细过程，首先将每个树转化为二叉的状态，如图所示。
【大数据】LSM树，专为海量数据读写而生的数据结构
Joker_ZJN的博客
04-24 978
一文详聊LSM树这种专为海量数据读写而生的数据结构
C#基础之冒泡排序
AMrss的博客
04-27 207
排序初探。
平衡二叉树 java
10-12
平衡二叉树是一种特殊的二叉搜索树，它的左右子树高度差不超过1。Java中可以通过自定义节点类和旋转操作实现平衡二叉树。 以下是一个简单的平衡二叉树的Java实现： ```java class Node { int val, height; Node left, right; Node(int val) { this.val = val; this.height = 1; } } class AVLTree { Node root; int height(Node node) { if (node == null) return 0; return node.height; } int balanceFactor(Node node) { if (node == null) return 0; return height(node.left) - height(node.right); } void updateHeight(Node node) { node.height = Math.max(height(node.left), height(node.right)) + 1; } Node rotateLeft(Node node) { Node right = node.right; node.right = right.left; right.left = node; updateHeight(node); updateHeight(right); return right; } Node rotateRight(Node node) { Node left = node.left; node.left = left.right; left.right = node; updateHeight(node); updateHeight(left); return left; } Node balance(Node node) { if (balanceFactor(node) > 1) { if (balanceFactor(node.left) < 0) { node.left = rotateLeft(node.left); } return rotateRight(node); } else if (balanceFactor(node) < -1) { if (balanceFactor(node.right) > 0) { node.right = rotateRight(node.right); } return rotateLeft(node); } updateHeight(node); return node; } Node insert(Node node, int val) { if (node == null) return new Node(val); if (val < node.val) { node.left = insert(node.left, val); } else { node.right = insert(node.right, val); } return balance(node); } void inorder(Node node) { if (node == null) return; inorder(node.left); System.out.print(node.val + " "); inorder(node.right); } } public class Main { public static void main(String[] args) { AVLTree tree = new AVLTree(); tree.root = tree.insert(tree.root, 10); tree.root = tree.insert(tree.root, 20); tree.root = tree.insert(tree.root, 30); tree.root = tree.insert(tree.root, 40); tree.root = tree.insert(tree.root, 50); tree.root = tree.insert(tree.root, 25); tree.inorder(tree.root); // 输出：10 20 25 30 40 50 } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值