数据结构-二叉树(一)

最新推荐文章于 2023-08-31 10:36:21 发布
最新推荐文章于 2023-08-31 10:36:21 发布
阅读量96 收藏
点赞数 1
分类专栏： 基础知识 Java 数据结构 文章标签： Binary Tree BinaryTree 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qcl108/article/details/109392000
版权
Java 同时被 3 个专栏收录
102 篇文章 0 订阅
订阅专栏
基础知识
92 篇文章 0 订阅
订阅专栏
数据结构
16 篇文章 0 订阅
订阅专栏

Binary Tree

树(Tree)

  • 树与数组& 链表对比
  1. 数组存储
  • 优点: 通过下标访问元素, 速度快
  • 缺点: 检索具体元素值, 或数组底部或元素与元素之间插入新元素或删除元素, 效率都很低
  1. 链式存储
  • 优点: 插入和删除效率较好
  • 缺点: 检索效率很低
  1. 树存储
  • 增删改查4样性能都比较好

二叉树(Binary Tree)

  1. 每个节点最多只能有两个子节点, 一个左节点一个右节点
  2. 如果二叉树的所有叶子节点都在最后一层, 且节点总数=2^n-1, n为层数, 则称为满二叉树
  3. 如果二叉树的所有叶子节点都在最后一层或者倒数第二层, 且最后一层的叶子节点在左边连续, 倒数第二层的叶子节点在右边连续, 则称为完全二叉树
    * 满二叉树肯定是完全二叉树, 而完全二叉树不一定是满二叉树

三种遍历

  • 前序遍历:
  1. 先输出根节点, 再递归输出左子树, 最后递归输出右子树
  2. 左右子树从父节点往下遍历输出, 左节点优先于右节点. 依次父左右顺序输出
  • 中序遍历:
  1. 先递归输出左子树, 再输出根节点, 最后递归输出右子树
  2. 左右子树从最左, 且最底节点开始输出. 依次左父右顺序输出
  • 后序遍历:
  1. 先递归输出左子树, 再递归输出右子树, 最后输出根节点
  2. 左右子树从最左, 且最底节点开始输出. 依次左右父顺序输出

* 看根节点的输出顺序, 就可以确定是什么遍历了


public class BinaryTreeApp {
    public static void main(String[] args) {
        /** 创建二叉树实例*/
        BinaryTree binaryTree = new BinaryTree();
        /** 创建多个结点*/
        Node node1 = new Node(1, "节点1"); // root
        Node node2 = new Node(2, "节点2");
        Node node3 = new Node(3, "节点3");
        Node node4 = new Node(4, "节点4");
        Node node5 = new Node(5, "节点5");
        Node node6 = new Node(6, "节点6");
        Node node7 = new Node(7, "节点7");
        Node node8 = new Node(8, "节点8");
        Node node9 = new Node(9, "节点9");
        /** 设定根节点*/
        binaryTree.setRoot(node1);
        /** 手动设定各节点*/
        node1.setLeft(node2);
        node1.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        node4.setLeft(node8);
        node4.setRight(node9);
        node5.setLeft(node6);
        node5.setRight(node7);
        System.out.println("前序遍历:");
        binaryTree.preOrder();
        System.out.println("中序遍历:");
        binaryTree.infixOrder();
        System.out.println("后序遍历:");
        binaryTree.postOrder();
    }
}

/** 定义二叉树*/
class BinaryTree {
    private Node root;

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

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

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

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

/** 定义节点*/
class Node {
    private int no;
    private String name;
    private Node left;
    private Node right;

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

    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 Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node [no=" + no + ", name=" + name + "]";
    }

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

    /** 中序遍历*/
    public void infixOrder() {
        /** 1. 递归向左子树中序遍历*/
        if(this.left != null) {
            this.left.infixOrder();
        }
        /** 2. 输出父结点*/
        System.out.println(this);
        /** 3. 递归向右子树中序遍历*/
        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);
    }

}

输出:
> 前序遍历:
> Node [no=1, name=节点1]
> Node [no=2, name=节点2]
> Node [no=3, name=节点3]
> Node [no=5, name=节点5]
> Node [no=6, name=节点6]
> Node [no=7, name=节点7]
> Node [no=4, name=节点4]
> Node [no=8, name=节点8]
> Node [no=9, name=节点9]
> 中序遍历:
> Node [no=2, name=节点2]
> Node [no=1, name=节点1]
> Node [no=6, name=节点6]
> Node [no=5, name=节点5]
> Node [no=7, name=节点7]
> Node [no=3, name=节点3]
> Node [no=8, name=节点8]
> Node [no=4, name=节点4]
> Node [no=9, name=节点9]
> 后序遍历:
> Node [no=2, name=节点2]
> Node [no=6, name=节点6]
> Node [no=7, name=节点7]
> Node [no=5, name=节点5]
> Node [no=8, name=节点8]
> Node [no=9, name=节点9]
> Node [no=4, name=节点4]
> Node [no=3, name=节点3]
> Node [no=1, name=节点1]

查找节点


public class BinaryTreeApp {
    public static void main(String[] args) {
        /** 创建二叉树实例*/
        BinaryTree binaryTree = new BinaryTree();
        /** 创建多个结点*/
        Node node1 = new Node(1, "节点1"); // root
        Node node2 = new Node(2, "节点2");
        Node node3 = new Node(3, "节点3");
        Node node4 = new Node(4, "节点4");
        Node node5 = new Node(5, "节点5");
        /** 设定根节点*/
        binaryTree.setRoot(node1);
        /** 手动设定各节点*/
        node1.setLeft(node2);
        node1.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);

        System.out.println("前序遍历查找:");
        Node resNode = binaryTree.preOrderSearch(5);
        if (resNode != null) {
            System.out.printf("找到了, 信息为 no=%d name=%s\n", resNode.getNo(), resNode.getName());
        } else {
            System.out.printf("没有找到 no=%d", 5);
        }

        System.out.println("中序遍历查找:");
        Node resNode2 = binaryTree.infixOrderSearch(5);
        if (resNode2 != null) {
            System.out.printf("找到了, 信息为 no=%d name=%s\n", resNode2.getNo(), resNode2.getName());
        } else {
            System.out.printf("没有找到 no=%d", 5);
        }

        System.out.println("后序遍历查找:");
        Node resNode3 = binaryTree.postOrderSearch(5);
        if (resNode3 != null) {
            System.out.printf("找到了, 信息为 no=%d name=%s\n", resNode3.getNo(), resNode3.getName());
        } else {
            System.out.printf("没有找到 no=%d", 5);
        }
    }
}

/** 定义二叉树*/
class BinaryTree {
    private Node root;

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

    /** 前序遍历查找*/
    public Node preOrderSearch(int no) {
        if(root != null) {
            return root.preOrderSearch(no);
        } else {
            return null;
        }
    }

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

    /** 后序遍历查找*/
    public Node postOrderSearch(int no) {
        if(root != null) {
            return this.root.postOrderSearch(no);
        }else {
            return null;
        }
    }
}

/** 定义节点*/
class Node {
    private int no;
    private String name;
    private Node left;
    private Node right;

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

    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 Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node [no=" + no + ", name=" + name + "]";
    }

    /** 前序遍历查找*/
    public Node preOrderSearch(int no) {
        System.out.println("进入前序遍历");
        /** 判断要查找的节点是否为当前节点*/
        if(this.no == no) {
            return this;
        }

        Node resNode = null;
        /** 左递归前序查找*/
        if(this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        /** 说明左子树中找到了指定节点*/
        if(resNode != null) {
            return resNode;
        }
        /** 右递归前序查找*/
        if(this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }

        return resNode;
    }

    /** 中序遍历查找*/
    public Node infixOrderSearch(int no) {
        Node resNode = null;
        /** 左递归中序查找*/
        if(this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        /** 说明左子树中找到了指定节点*/
        if(resNode != null) {
            return resNode;
        }

        System.out.println("进入中序查找");
        /** 判断要查找的节点是否为当前节点*/
        if(this.no == no) {
            return this;
        }
        /** 右递归中序查找*/
        if(this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }

        return resNode;
    }

    /** 后序遍历查找*/
    public Node postOrderSearch(int no) {
        Node resNode = null;
        /** 左递归后序查找*/
        if(this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        /** 说明左子树中找到了指定节点*/
        if(resNode != null) {
            return resNode;
        }
        /** 右递归后序查找*/
        if(this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        /** 说明右子树中找到了指定节点*/
        if(resNode != null) {
            return resNode;
        }
        System.out.println("进入后序查找");
        /** 判断要查找的节点是否为当前节点*/
        if(this.no == no) {
            return this;
        }

        return resNode;
    }

}

输出:
> 前序遍历查找: 遍历次数为4次
> 进入前序遍历
> 进入前序遍历
> 进入前序遍历
> 进入前序遍历
> 找到了, 信息为 no=5 name=节点5
> 中序遍历查找: 遍历次数为3次
> 进入中序查找
> 进入中序查找
> 进入中序查找
> 找到了, 信息为 no=5 name=节点5
> 后序遍历查找: 遍历次数为2次
> 进入后序查找
> 进入后序查找
> 找到了, 信息为 no=5 name=节点5

删除节点

  • 规则: 要删除的节点, 如果是非叶子节点, 则删除该子树

public class BinaryTreeApp {
    public static void main(String[] args) {
        /** 创建二叉树实例*/
        BinaryTree binaryTree = new BinaryTree();
        /** 创建多个结点*/
        Node node1 = new Node(1, "节点1"); // root
        Node node2 = new Node(2, "节点2");
        Node node3 = new Node(3, "节点3");
        Node node4 = new Node(4, "节点4");
        Node node5 = new Node(5, "节点5");
        /** 设定根节点*/
        binaryTree.setRoot(node1);
        /** 手动设定各节点*/
        node1.setLeft(node2);
        node1.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        System.out.println("删除前, 前序遍历");
        binaryTree.preOrder();
        binaryTree.delNode(5);
        System.out.println("删除后, 前序遍历");
        binaryTree.preOrder();
    }
}

/** 定义二叉树*/
class BinaryTree {
    private Node root;

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

    /** 删除结点*/
    public void delNode(int no) {
        if(root != null) {
            /** 删除结点*/
            if(root.getNo() == no) {
                root = null;
            } else {
                /** 递归删除*/
                root.delNode(no);
            }
        }else{
            System.out.println("空树, 不能删除");
        }
    }

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

/** 定义节点*/
class Node {
    private int no;
    private String name;
    private Node left;
    private Node right;

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

    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 Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node [no=" + no + ", name=" + name + "]";
    }

    /** 删除结点*/
    public void delNode(int no) {
        /** 如果当前结点的左子结点不为空, 且左子结点就是要删除结点, this.left = null; (结束递归删除)*/
        if(this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        
        /** 如果当前结点的右子结点不为空, 且右子结点就是要删除结点, this.right= null; (结束递归删除)*/
        if(this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }

        /** 向左子树进行递归删除*/
        if(this.left != null) {
            this.left.delNode(no);
        }

        /** 向右子树进行递归删除*/
        if(this.right != null) {
            this.right.delNode(no);
        }
    }

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

}

输出:
> 删除前, 前序遍历
> Node [no=1, name=节点1]
> Node [no=2, name=节点2]
> Node [no=3, name=节点3]
> Node [no=5, name=节点5]
> Node [no=4, name=节点4]
> 删除后, 前序遍历
> Node [no=1, name=节点1]
> Node [no=2, name=节点2]
> Node [no=3, name=节点3]
> Node [no=4, name=节点4]

如果您觉得有帮助，欢迎点赞哦 ~ 谢谢!!

Shawn Jeon
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树基本概念
AiTTTTTT的博客
02-15 5882
树的定义： 树（Tree）是n（n>=0）个结点的有限集，当n=0时称为空树，在任意一颗非空树中： （1） 有且仅有一个特定的称为根（root）的结点； （2）当n>1时，其余结点可分为m（m>0）个互不相交的有限集T1,T2，......,Tm,其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）; 树节点的分类： 结点拥有的子树数称为结点的度（Degree），度为0的结点称为叶结点（Leaf）或终端结点；度不为0的结点称为非终端结点或分支结点。除根节点外，分支结点
数据结构-二叉树(二)
woainigui8888的博客
03-15 376
二叉树是n个结点的有限集合,该集合或者空集(称为二叉树),或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。二叉树特点 ①每个结点最多有两棵子树,所以二叉树不存在度大于2的结点。注意不是只有两棵子树,而是最多有。没有子树或者有一棵子树都是可以的。 ②左子树和右子树是有顺序的,次序不能任意颠倒。 ③即使树中某结点只有一棵子树,也要区分它是左子树还是右子树。特殊二叉树
8张图详解电源二叉树
01-12
此次就给大家介绍一个电源二叉树分析实例。 电源二叉的树分析步骤： 寻源： 即找电源入口 顺藤摸瓜： 即顺着电源入口找到每路电源转换路径，直至找到使用此电源的终端（终负载）实例分析一路电源 图1示是电源入口DC_5V_IN通过0R电阻R128转换为AO_5V电源；图2示AO_5V再转过器件U1转换为VDDIO_AO3.3V电源，其电流为2A；图6示VDDIO_AO3.3V一路通过器件U5转换为VCC1.8V电源，其电流为500mA；图8示 VDDIO_AO3.3V另一路通过器件U4转换为VDDIO_AO18电源，其电流为500mA，此路电源分析完毕。其他电源路径可作类似推理。 原理
什么是二叉树
qq_52208569的博客
03-31 1715
文章目录前言一、什么是二叉树二、二叉树的性质三、满二叉树四、完全二叉树总结 前言 为什么要重点研究每个结点最多只有两个"叉"的树？ 二叉树的结构最简单，规律性最强。 可以证明，所有树都能转为唯一对应的二叉树，不失一般性。 普通树（多叉树）若不转化为二叉树，则运算很难实现。本节将给大家介绍二叉树。 一、什么是二叉树 简单地理解，满足以下两个条件的树就是二叉树： 本身是有序树； 树中包含的各个节点的度不能超过 2，即只能是 0、1 或者 2； 图 1 二叉树示意图 二、二叉树的性质 二叉..
一文读懂二叉树
清晨qc的博客
06-08 548
二叉树是一种由节点（Node）组成的数据结构，每个节点最多有两个子节点。它具有良好的层次结构，便于搜索和遍历。二叉树的定义和操作方法可以通过面向对象的方式来理解，每个节点都是一个对象，节点之间通过引用关系连接。如图所示：这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。根节点为 k = 1 的深度开始计算，如图所示的二叉树，它的深度为 4 ，所以这棵满二叉树有15个节点。
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构之树（二）
以前冷现在热
11-19 286
二叉树定义 二叉树（Binary Tree）是n（n≥0）个结点的有限集合，该集合可以为空集称为空二叉树，或者一个根结点和两个互不相交的,分别称为根结点的左子树和右子树的二叉树组成。 如开/关，0/1,真/假，上/下，对/错等，对于这种在某个阶段都是两种可能性的情况，我们可以用树形结构来建模，而这种树就是特殊的树形结构称为二叉树。 二叉树的特点： 每个结点最多两棵子树，没有或一棵也行。 ...
数据结构--二叉树--思维导图.pdf
08-29
"数据结构--二叉树--思维导图" 二叉树是一种常见的数据结构，它是一种树形结构，每个节点最多有两个孩子节点，分别是左子树和右子树。二叉树可以用来存储大量数据，并且可以快速地查找、插入和删除数据。 二叉树的...
数据结构-二叉树基础.pdf
最新发布
04-15
数据结构 -二叉树基础.pdf
数据结构-二叉树的基本操作
09-26
二叉树相关的完整代码
数据结构-二叉树相关功能及算法
06-11
二叉树是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。在计算机科学中，二叉树的应用广泛，涉及搜索、排序、编译器设计等多个领域。本主题将深入探讨...
数据结构-二叉树 JAVA语言实现
10-16
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的数据结构，被广泛应用于算法设计、数据库系统、编译器等领域。本教程将详细阐述如何使用JAVA语言实现二叉树的相关操作。 首先，我们要了解二叉树的...
二叉树的介绍
weixin_45639224的博客
08-31 540
二叉树的介绍
二叉树是啥,万字长文，看这一篇就够了
Sunny_dzy的博客
09-15 377
所以左子树的节点总数我们可以直接得到，是2^left - 1，加上当前这个root节点，则正好是2^3，即 8。由于题中已经告诉我们这是一颗完全二叉树，我们又已知了完全二叉树除了最后一层，其他层都是满的，并且最后一层的节点全部靠向了左边。，而未到达最后的结束点之前，占用的栈空间一直没有释放，如果递归调用次数过多，就可能导致占用的栈资源超过线程的最大值，从而导致栈溢出，导致程序的异常退出。这里强调一下子树的概念：设T是有根树，a是T中的一个顶点，由a以及a的所有后裔（后代）导出的子图称为有向树T的子树。
二叉树的基本概念
weixin_63091319的博客
06-13 2365
二叉树的相关概念
数据结构之二叉树（BinaryTree）
weixin_30532973的博客
01-17 732
导读 　　二叉树是一种很常见的数据结构，但要注意的是，二叉树并不是树的特殊情况，二叉树与树是两种不一样的数据结构。 目录 　 　一、 二叉树的定义 　　二、二叉树为何不是特殊的树 　　三、二叉树的五种基本形态 　　四、二叉树相关术语 　　五、二叉树的主要性质（6个） 　　六、二叉树的存储结构（2种） 　　七、二叉树的遍历算法（4种） 　　八、二叉树的基本应用：二叉排序树、平衡二...
二叉树的简介
风间琉璃的博客
11-02 513
文章目录前言????二叉树的定义????二叉树的类型????斜树????满二叉树????完全二叉树????二叉树的存储结构总结 前言 提示：以下是本篇文章正文内容 ????二叉树的定义 二叉树是n(n>=0)个节点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根节点和两颗互不相交的，分别称为根节点的左子树和右子树的二叉树组成 二叉树的特点： (1)每个节点最多有两颗子树 (2)二叉树是有序的，其次序不能随意颠倒 这两颗二叉树是不一样的 二叉树的基本形态：包含五种 注：二叉树和树
Java MultipartFile 上传文件/上传图片 亲测
Shawn Jeon`s blog
09-12 8779
Java MultipartFile 上传文件/上传图片1. 判断允许上传文件的 后缀/图片后缀工具类2. 上传接口3. 上传成功 1. 判断允许上传文件的 后缀/图片后缀工具类 import org.springframework.stereotype.Component; import java.io.File; import java.util.Arrays; import java.ut...
树型结构与线性结构对比：数据结构第6讲 - 二叉树详解
总结来说，本讲内容涵盖了树的定义、不同类型（如二叉树）、遍历方法、特殊类型的树（如线索二叉树和哈夫曼树）、以及对树进行操作的方法，这些都是理解数据结构特别是非线性数据结构如树的基础知识。学习这些内容有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值