红黑树学习笔记及java代码实现

最新推荐文章于 2024-05-21 10:23:42 发布
最新推荐文章于 2024-05-21 10:23:42 发布
阅读量186 收藏
点赞数 1
文章标签： java 数据结构 hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56892136/article/details/123241376
版权

红黑树学习笔记及java代码实现

一、什么是树？

树(tree)是一种抽象数据类型(ADT)，用来模拟具有树状结构性质的数据集合。它是由n (n>0)个有限节点通过连接它们的边组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上,而叶朝下的。
树有很多种，向上面的一个节点有多余两个的子节点的树，称为多路树，而每个节点最多只能有两个子节点的一种形式称为二叉树。

二、树结构的常用术语

在这里插入图片描述
①、路径:顺着节点的边从一个节点走到另一个节点，所经过的节点的顺序排列就称为“路径"。
②、根:树顶端的节点称为根。一棵树只有一个根，如果要把一个节点和边的集合称为树，那么从根到其他任何一个节点都必须有且只有一条路径。A是根节点。
③、父节点:若一个节点含有子节点，则这个节点称为其子节点的父节点
④、子节点:一个节点含有的子树的节点称为该节点的子节点;F、G是C节点的子节点。
⑤、兄弟节点:具有相同父节点的节点互称为兄弟节点;F、G节点互为兄弟节点。
⑥、叶节点:没有子节点的节点称为叶节点，也叫叶子节点，比如上图的H、E、F、G都是叶子节点。
⑦、子树:每个节点都可以作为子树的根，它和它所有的子节点、子节点的子节点等都包含在子树中。
⑧、节点的层次:从根开始定义，根为第一层，根的子节点为第二层，以此类推。
⑨、深度:对于任意节点n,n的深度为从根到n的唯一路径长，根的深度为O;(从上往下看)
⑩、高度:对于任意节点n,n的高度为从n到一片树叶的最长路径长，所有树叶的高度为O;(从下往上看)

三、二叉搜索树

二叉树：树的每个节点最多只能有两个子节点。
上面的图每个节点只有两个节点，是二叉树，并且二叉树的子节点称为“左子节点”和“右子节点”。

二叉搜索树

如果我们给二叉树加一个额外的条件，就可以得到一种被称作二叉搜索树(binary search tree)的特殊二叉树。
二叉搜索树要求:
若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值;
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值;
它的左、右子树也分别为二叉排序树。

二叉搜索树-遍历节点

遍历树是根据一种特定的顺序访问树的每一个节点。比较常用的有前序遍历，中序遍历和后序遍历。而二叉搜索树最常用的是中序遍历。

①、中序遍历:左子树——》根节点——》右子树
②、前序遍历:根节点——》左子树——》右子树
③、后序遍历:左子树——》右子树——》根节点
在这里插入图片描述

二叉搜索树-删除节点

1.删除没有子节点的节点

只需改变该节点的父节点引用该节点的值，即将其引用改为null即可
在这里插入图片描述

2.删除有一个子节点的节点

将其父节点原本只想该节点的引用，改为指向该节点的子节点
在这里插入图片描述

3.删除有两个子节点的节点

在这里插入图片描述
当删除的节点存在两个子节点，那么删除之后，两个子节点的位置我们就没办法处理了。
既然处理不了，我们就想到一种办法，用另一个节点来代替被删除的节点，那么用哪一个节点来代替呢?
我们知道二叉搜索树中的节点是按照关键字来进行排列的，某个节点的关键字次高节点是它的中序遍历后继节点。用后继节点来代替删除的节点．显然该二叉搜索树还是有序的.

四、红黑树

红黑树性质

在这里插入图片描述
红黑树并不是一个完美平衡二叉查找树，从图上可以看到，根结点P的左子树显然比右子树高,
但左子树和右子树的黑结点的层数是相等的，也即任意一个结点到到每个叶子结点的路径都包含数量相同的黑结点(性质5)。所以我们叫红黑树这种平衡为黑色完美平衡。

红黑树可以自平衡，靠的是三种操作:左旋、右旋和变色

1.变色:结点的颜色由红变黑或由黑变红。
2.左旋:以某个结点作为支点(旋转结点)，其右子结点变为旋转结点的父结点，右子结点的左子结点变为旋转结点的右子结点，左子结点保持不变
3.右旋:以某个结点作为支点(旋转结点)，其左子结点变为旋转结点的父结点，左子结点的右子结点变为旋转结点的左子结点，右子结点保持不变

左旋：
在这里插入图片描述
右旋：
在这里插入图片描述

红黑树插入情景分析

情景1：红黑树为空树

最简单的一种情景，直接把插入结点作为根结点就行
注意:根据红黑树性质2:根节点是黑色。还需要把插入结点设为黑龟。

情景2：插入节点的key已存在

处理:更新当前节点的值，为插入节点的值

情景3：插入节点的父节点为黑节点

由于插入的结点是红色的，当插入结点的黑色时，并不会影响红黑树的平衡，直接插入即可，无需做自平衡。
在这里插入图片描述

情景4：插入节点的父节点为红色（有多种情况）

再次回想下红黑树的性质2:根结点是黑色。如果插入节点的父结点为红结点，那么该父结点不可能为根结点，所以插入结点总是存在祖父结点。这—点很关键，因为后续的旋转操作肯定需要祖父结点的参与。

插入情景4.1∶叔叔结点存在并且为红结点
依据红黑树性质4可知，红色节点不能相连==>祖父结点肯定为黑结点;
因为不可以同时存在两个相连的红结点。那么此时该插入子树的红黑层数的情况是:黑红红。显然最简单的处理方式是把其改为:红黑红处理:
1.将P和U节点改为黑色
2.将PP改为红色
3.将PP设置为当前节点，进行后续处理
在这里插入图片描述

可以看到，我们把PP结点设为红色了，如果PP的父结点是黑色，那么无需再做任何处理;
但如果PP的父结点是红色，则违反红黑树性质了。所以需要将PP设置为当前节点，继续做插入操作自平衡处理，直到平衡为止。

插入情景4.2：叔叔结点不存在或为黑结点，并且插入结点的父亲结点是祖父结点的左子结点
注意：单纯从插入前来看，叔叔结点非红即空（NIL结点），否则的话破坏了红黑树性质5，此路径会比其他路径多一个黑色结点。
在这里插入图片描述
插入情景4.2.1： 新插入节点，为其父节点的左子节点（LL红色情况）
在这里插入图片描述
处理：
1.变颜色：将P设置为黑色，将PP设置为红色
2.对PP节点进行右旋

插入情景4.2.2：新插入节点，为其父节点的右子节点（LR红色情况）

在这里插入图片描述
处理：
1.对P进行左旋
2.将P设置为当前节点，得到LL红色情况
3。按照LL红色情况处理（1.变色 2.右旋PP）

插入情景4.3:叔叔结点不存在或为黑结点，并且插入结点的父亲结点是祖父结点的右子结点
该情景对应情景4.2，只是方向反转，直接看图。
在这里插入图片描述
插入情景4.3.1:新插入节点，为其父节点的右子节点(RR红色情况)

处理：
1.变颜色:将P设置为黑色，将PP设置为红色
2.对PP节点进行左旋

插入情景4.3.2:新插入节点，为其父节点的左子节点(RL红色情况)
在这里插入图片描述
处理:
1.对P进行右旋
2.将P设置为当前节点，得到RR红色情况3.按照RR红色情况处理(1.变颜色2.左旋PP)

五、红黑树代码

RBTree：

public class RBTree<K extends Comparable<K>,V> {
    //定义颜色
    private static final boolean RED=true;
    private static final boolean BLACK=false;
     //树根
    private RBNode root;
    static class RBNode<K extends Comparable<K>,V>
    {
       private RBNode parent;
       private RBNode left;
       private RBNode right;
       private  boolean color;
       private K key;
       private V value;

        public RBNode() {
        }

        public RBNode(RBNode parent, RBNode left, RBNode right, boolean color, K key, V value) {
            this.parent = parent;
            this.left = left;
            this.right = right;
            this.color = color;
            this.key = key;
            this.value = value;
        }
            //get 和 set
        public RBNode getParent() {
            return parent;
        }

        public void setParent(RBNode parent) {
            this.parent = parent;
        }

        public RBNode getLeft() {
            return left;
        }

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

        public RBNode getRight() {
            return right;
        }

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

        public boolean isColor() {
            return color;
        }

        public void setColor(boolean color) {
            this.color = color;
        }

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }
    }

    public RBNode getRoot() {
        return root;
    }

    public void setRoot(RBNode root) {
        this.root = root;
    }
    /*
    * 获取当前节点的父节点
    *@param node
    * */

    private  RBNode parentOf(RBNode node)
    {
        if(node!=null)
        {
            return node.parent;
        }
        return null;
    }
   /*
    *  节点是否为红色
    *  @param node
     * */
     private  boolean isRed(RBNode node)
     {
         if(node!=null)
             return node.color==RED;
         return false;
     }
    /*
     *  节点是否为黑色
     *  @param node
     * */
    private  boolean isBlack(RBNode node)
    {
        if(node!=null)
            return node.color==BLACK;
        return false;
    }
    /*
    * 设置节点为红色
    * @param node
    * */
  private void setRed(RBNode node)
  {
      if(node!=null)
          node.color=RED;

  }
    /*
     * 设置节点为黑色
     * @param node
     * */
    private void setBlack(RBNode node)
    {
        if(node!=null)
            node.color=BLACK;

    }
    /*
    * 中序打印二叉树
    * */
    public  void inOrderPrint()
    {
         inOrderPrint(this.root);
    }
    public void inOrderPrint(RBNode root)
    {
        if(root!=null)
        {
            inOrderPrint(root.left);
            System.out.println("key:"+root.key+",value:"+root.value);
            inOrderPrint(root.right);
        }
    }
    /*
    * 左旋  左旋x节点
    *    p                       p
    *    |                       |
    *    x                       y
    *   / \      ----->         / \
    *  lx  y                   x   ry
    *     / \                 / \
    *    ly  ry              lx  ly
    *
    * 1.将x的右子节点指向y的左子节点（ly）,并将y的左子节点的父节点更新为x
    * 2.当x的父节点（不为空时），更新y的父节点为x的父节点，并将x的父节点指定子树（当前x的子树位置）指定为y
    * 3.将x的父节点更新为y，将y的左子节点更新为x
    *
    *     *
    * */
    private void leftRotate(RBNode x)
    {
        RBNode y=x.right;
        //将x的右子节点指向y的左子节点（ly）
        x.right=y.left;
        //将y的左子节点的父节点更新为x
        if(y.left!=null)
        {
            y.left.parent=x;
        }
        //当x的父节点（不为空时），更新y的父节点为x的父节点
        if(x.parent!=null)
        {
            y.parent=x.parent;
            if(x==x.parent.left)
            {
                //x是左子节点
                x.parent.left=y;
            }
            else {

                x.parent.right=y;
            }
        }else
        {
            this.root=y;
            this.root.parent=null;
        }
        //3.将x的父节点更新为y，将y的左子节点更新为x
        x.parent=y;
        y.left=x;

    }

    /*
    * 右旋
    *    p                       p
    *    |                       |
    *    y                       x
    *   / \      ----->         / \
    *  x  ry                   lx   y
    * / \                          / \
    *lx ly                        ly  ry
    *
    * 1.将y的左子节点指向x的右子节点，并且更新x的右子节点的父节点为y
    * 2.当y的父节点不为空时 更新x的父节点为y的父节点，更新y的父节点的指定子节点（y当前的位置）为x
    * 3.更新y的父节点为x，更新x的右子节点为y
    * */
    private  void rightRotate(RBNode y)
    {
        //1.将y的左子节点指向x的右子节点，并且更新x的右子节点的父节点为y
        RBNode x=y.left;
        y.left=x.right;
        if(x.right!=null)
        {
            x.right.parent=y;
        }

        //当y的父节点不为空时 更新x的父节点为y的父节点，更新y的父节点的指定子节点（y当前的位置）为x
        if(y.parent!=null)
        {
            x.parent=y.parent;
            if(y==y.parent.left)
            {
                y.parent.left=x;
            }
            else
            {
                y.parent.right=x;
            }
        }else
        {
            this.root=x;
            this.root.parent=null;
        }
       //3.更新y的父节点为x，更新x的右子节点为y
        y.parent=x;
        x.parent=y;
    }

    /*
    * 公开的插入方法
    * @param key
    * @param value
    * */
    public  void insert(K key,V value)
    {
        RBNode node=new RBNode();
        node.setKey(key);
        node.setValue(value);
        //新节点一定是红色
        node.setColor(RED);
        insert(node);
    }
    private void insert(RBNode node)
    {
        //第一步：查找当前node的父节点
        RBNode parent=null;
        RBNode x=this.root;
        while(x!=null)
        {
            parent=x;
            //cmp>0 说明node.key大于x.key需要到x的右子树查找
            // =0 说明node.key等于x.key 需要进行替换操作
            // <0  需要到x的左子树查找
            int cmp=node.key.compareTo(x.key);

            if(cmp>0)
            {
                x=x.right;
            }else if(cmp==0)
            {
                x.setValue(node.getValue());
                return;
            }else
            {
                x=x.left;
            }
        }
        node.parent=parent;
        //判断node与parent的key谁大
        if(parent!=null) {
            int cmp = node.key.compareTo(parent.key);
            if(cmp>0){
                //把node放入parent的右子节点
                parent.right=node;
            }
            else{
                //放入左子节点
                parent.left=node;

            }
        }else
        {
            this.root=node;
        }
      //需要调用修复红黑树平衡的方法
          insertFixUp(node);

    }
    /*
    *   插入后修复红黑树平衡的方法
    * 情景一、红黑树为空树：将根节点染色为黑色
    * 情景二、插入节点的key已经存在：无需修复红黑树平衡
    * 情景三、插入节点的父节点为黑色： 因为所插入的路径，黑色节点没有变化，所以红黑树依然平衡，无需处理
    * 情景四、插入节点的父节点为红色
    *     4.1、叔叔节点存在，并且为红色（父叔 双红）：
    *         将爸爸和叔叔染色为黑，爷爷染色为红，并且再以爷爷节点为当前节点，进行下一轮处理
    *     4.2、叔叔节点不存在，或者为黑色，父节点为爷爷节点的左子树
    *       4.2.1、插入节点为其父节点的左子节点（LL情况）：
    *         将爸爸染色为黑，爷爷染色为红 然后以爷爷节点右旋
    *       4.2.2、插入节点为其父节点的右子节点（LR情况）：
    *         以爸爸节点进行一次左旋，得到LL双红的情景（4.2.1），然后指定爸爸节点为当前节点进行下一轮处理
    *     4.3、叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
    *       4.3.1、插入节点为其父节点的右子节点（RR情况）：
    *          将爸爸染色为黑，将爷爷染色为红，然后以爷爷节点左旋，就完成了
    *       4.3.2、插入节点为其父节点的左子节点（RL情况）：
    *          以爸爸节点进行一次右旋，得到RR双红（4.3.1） 然后指定爸爸节点为当前节点进行下一轮处理
    *
    *
    * */
    private void insertFixUp(RBNode node)
    {
        this.root.setColor(BLACK);
        RBNode parent=parentOf(node);
        RBNode gparent=parentOf(parent);
        if(parent!=null&&isRed(parent))
        {
            //情景四、插入节点的父节点为红色

            //若父节点是红色 那么一定存在爷爷节点 因为根节点不可能是红色
            RBNode uncle=null;
            if(parent==gparent.left)
            {
                uncle=gparent.right;
                // 4.1、叔叔节点存在，并且为红色（父叔 双红）
                if(uncle!=null&&isRed(uncle))
                {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }
                // 4.2、叔叔节点不存在，或者为黑色
                if(uncle==null||isBlack(uncle))
                {
                    //4.2.1、插入节点为其父节点的左子节点（LL情况）：
                    if(node == parent.left){
                        setBlack(parent);
                        setRed(gparent);
                        rightRotate(gparent);
                        return;
                    }
                    if(node==parent.right)
                    {
                        leftRotate(parent);
                        insertFixUp(parent);
                        return;
                    }


                }
            }else
            {
                //父节点为爷爷节点的左子树
                uncle=gparent.left;
                // 4.1、叔叔节点存在，并且为红色（父叔 双红）
                if(uncle!=null&&isRed(uncle))
                {
                    setBlack(parent);
                    setBlack(uncle);
                    setRed(gparent);
                    insertFixUp(gparent);
                    return;
                }
                //4.3、叔叔节点不存在，或者为黑色，父节点为爷爷节点的右子树
                if(uncle==null||isBlack(uncle))
                {
                  // 4.3.1、插入节点为其父节点的右子节点（RR情况）
                    if(node==parent.right)
                    {
                        setBlack(parent);
                        setRed(gparent);
                        leftRotate(gparent);
                        return;
                    }
                    //4.3.2、插入节点为其父节点的左子节点（RL情况）
                    if(node==parent.left)
                    {
                        rightRotate(parent);
                        insertFixUp(parent);
                        return;
                    }
                }

            }

        }
    }


}

测试类：

public class Test {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        RBTree<String,Object> rbt=new RBTree<String, Object>();
        while(true)
        {
            System.out.println("请输入key:");
            String key=scanner.next();
            System.out.println();
            rbt.insert(key,null);
             TreeOperation.show(rbt.getRoot());
        }
    }

依次输入1、2、3、4、5、6、7、8、9，结果为：
在这里插入图片描述

学习视频：b站 小刘讲源码
红黑树打印的方法类TreeOperation：https://github.com/Roderickkkk/TreeOperation/blob/main/README.md

子夜听雨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java学习笔记
VanMonday的博客
05-12 945
兰智数加Java学习笔记
java算法实现红黑树完整代码示例
08-28
主要介绍了java算法实现红黑树完整代码示例，具有一定参考价值，需要的朋友可以了解下。
java 打印红黑树TreeOperation()类
weixin_42428778的博客
09-04 659
红黑树测试打印 public class RBTreeTest { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); RBTree<String, Object> rbt = new RBTree(); while (true) { System.out.println("请输入key: ");
红黑树学习笔记
weixin_40701758的博客
03-11 561
红黑树的学习记录
红黑树学习笔记（自己实现一个简单的红黑树）
weixin_46410481的博客
12-15 1133
红黑树的学习笔记（自己实现一个简单的红黑树） 最近在学习树的一些东西，想把树从头开始总结一下巩固自己的印象。 1、树结构入门 1.1、什么是树？ 树（tree）是一种抽象数据类型（ADT），用来模拟具有树状结构性质的数据集合。它是由n（n>0）个有限节点通过连接它们的边组成一个具有层次关系的集合。 把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是根朝上的，而叶是朝下的。 树有很多种，像下面的一个节点有多余两个子节点的树，称为多路树，而每个节点最多只能有两个子节点的一种形式称为二叉树。 节点：上
数据结构 - 学习笔记 - 红黑树
湖边的小屋圣迹
01-30 2182
所有结点非红即黑。（插入新结点默认红色，然后再按需调整）根结点必需是黑色。叶结点必需是黑色。叶结点是指最末端的空结点。通常在代码中直接用 null 表示，不会创建实际结点。红结点的子结点必需是黑。有两棵或无子树。（不能有连续的两个红结点）任意结点到叶节点经过的黑结点数量相同。（别忘记叶结点也是黑色结点 ）红黑树是234树的一种实现，所以学习红黑树前，先看红黑树前传——234树。它是一种自平衡的二叉查找树。2.1.二叉查找树的左子树所有结点值都=父。2.2.
Java学习笔记——集合类学习
2303_79232676的博客
03-20 992
以Collection根接口的一众实现保存的是单值数据，而以Map为根接口的一众实现保存的是键值（key-value）对数据。Map类型的集合使用键值对来保存对象，这意味着在保存对象时，需要同时提供两个对象，一个作为键（key），一个作为值（value）。List：一个有序的集合，可以包含重复的元素，提供了按索引访问的方式。
Collection集合 --java学习笔记
m0_71386740的博客
03-29 1272
常见List系列集合—— ArrayList、LinkdList：有序、可重复、有索引运行结果。
Java基础全程学习笔记（三）
2302_80888286的博客
04-18 1018
Java基础全程学习笔记（三）
Java 集合【学习笔记】Java 基础
做笔记，记录学习中遇到的问题。
03-25 836
JAVA集合：单列集合（List、Set）、双列集合（Map）、工具类（Arrays、Collections）的相关API。以及 ArrayList、LinkedList、Iterator、HashMap、TreeMap 的底层原理。
Java集合框架学习笔记
qq_51800384的博客
03-13 735
Collection集合包括有List和Set两种，是单列集合，每个元素包含一个值。LinkedHashSet集合特点：有序、不重复、无索引。：HashSet 默认不能对内容相同的两个不同对象去重。：增强for循环，本质是迭代器遍历集合的简化写法。HashSet集合特点：无序、不重复、无索引。TreeSet集合特点：排序、不重复、无索引。Set集合特点：无序、不重复、无索引。方法结合Lamdba对集合对象遍历。：让内容相同的两个对象的哈希值相同。）遍历集合的专用方法。方法一：让自定义类实现。
红黑树实现（java代码）
10-07
红黑树创建，插入，删除操作代码。包括创建，插入操作，删除操作，代码有详细的注释，java代码实现。
基于红黑树插入操作原理及java实现方法(分享)
08-28
下面小编就为大家分享一篇基于红黑树插入操作原理及java实现方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
通过Java实现红黑树及其可视化
12-09
通过Java实现红黑树及其可视化 对于节点的定义，包含节点的数值、节点的颜色、节点的父节点、节点的左右叶子结点 通过Java实现红黑树，包括红黑树的插入操作、删除操作、维护红黑树性质的操作以及常用的方法函数...
使用Java语言实现的rbtree红黑树.zip
03-21
红黑树 使用Java语言实现的rbtree红黑树
jar包增量更新分析
junlaiyan的专栏
05-16 269
借助jdeps分析出jar包的增量文件
Spring-Cloud 微服务
weixin_65127444的博客
05-15 900
先来思考一个问题*通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址（ip，端口）等硬编码到了代码中，这种做法存在许多问题：1.一旦服务提供者地址变化，就需要手工修改代码2. 一旦是多个服务提供者，无法实现负载均衡功能3.一旦服务变得越来越多，人工维护调用关系困难那么应该怎么解决呢，这时候就需要通过注册中心动态的实现。
java实现拼图小游戏
monkey108的博客
05-16 631
本文主要提供用java实现的拼图小游戏源代码。
SpringBoot Validation自定义注解之校验指定最小整数
最新发布
thinkers
05-21 28
1，引入核心关键依赖。
红黑树代码实现java
10-02
下面是一个红黑树的Java代码实现： ```java package RBTree; public class RedBlackTree { private RBTreeNode root; public void insert(int key) { RBTreeNode newNode = new RBTreeNode(key); if (root ==...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值