二叉排序树(BST)的处理笔记

最新推荐文章于 2023-04-10 15:29:17 发布
最新推荐文章于 2023-04-10 15:29:17 发布
阅读量1.6k 收藏 11
点赞数 17
分类专栏： java 笔记 文章标签： Java数据结构 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wuweihendidiao/article/details/123517639
版权
笔记 同时被 2 个专栏收录
33 篇文章 0 订阅
订阅专栏
java
26 篇文章 3 订阅
订阅专栏

学习视频【尚硅谷】数据结构与算法（Java数据结构与算法）_哔哩哔哩_bilibili

目录

二叉排序树的概念 

二叉排序树的创建和遍历

二叉排序树删除结点的处理

1,删除叶子结点

代码实现 

2.删除只有一颗子树的结点

代码实现 

3.删除有两颗子树的结点

代码实现

总代码

二叉排序树的概念 

二叉排序树：BST，对于二叉排序树的任何一个非叶子结点，要求左子结点的值比当前结点的值小，右子结点的值比当前结点的值大.

如果有相同的值，可以将该结点放在左子结点或右子结点.

 {7,3,10,12,5,1,9}对应的二叉排序树为

 

二叉排序树的创建和遍历



public class BST {
	
	public static void main(String[] args)
	{
		int[] arr= {7,3,10,12,5,1,9};
		BinarySortTree binarysorttree =new BinarySortTree();
		for(int i=0;i<arr.length;i++)//添加节点到二叉树
		{
			binarysorttree.add(new Node(arr[i]));//细节处理呀
		}
		//中序遍历二叉排序树
		System.out.println("中序遍历二叉排序树");
		binarysorttree.infixOrder();//1,3,5,7,9,12
	}

}

class BinarySortTree{
	
	private Node root;
	//添加节点的方法
	public void add(Node node)
	{
		if(root==null)
		{
			root=node;;
		}
		else
		{
			root.add(node);
		}
	}
	public void infixOrder()
	{
		if(root!=null)
		{
			root.infixOrder();
		}
		else
		{
			System.out.println("二叉树排序树为空，不能遍历");
		}
	}
}


class Node{
	int value;
	Node left;
	Node right;
	public Node(int value)
	{
		this.value=value;
	}	

	
	 public String toString() {
		 return "Node[value="+value+"]"; 
		 }
	 
	//添加节点的方法
	//递归
	public void add(Node node)
	{
		if(node==null)
		{
			return ;
		}
		//判断传入节点的值和当前子树的根节点的值的关系
		if(node.value<this.value)
		{
			if(this.left==null)
			{
				this.left=node;//为空的话就搞上去
			}
			else
			{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else
		{
			if(this.right==null)
			{
				this.right=node;
			}else
			{//递归的向右子树添加，可以跟上面的联系去理解
				this.right.add(node);
			}
			
		}
	}
	//中序遍历
	public void infixOrder()
	{
		if(this.left!=null)
		{
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right!=null)
		{
			this.right.infixOrder();
		}
	}	
}

二叉排序树删除结点的处理

有三种情况：

  1. 删除叶子结点
  2. 删除只有一颗子树的结点
  3. 删除有两颗子树的结点

1,删除叶子结点

  • 找到要删除的结点targetnode
  • 找到targetnode的父结点parent
  • 确定targetnode是parent的左子结点还是右子结点
  • 根据前面的情况来对应删除
  • 左子结点 parent.left=null;
  • 右子结点 parent.right=null;

代码实现 

public class BST {
	
	public static void main(String[] args)
	{
		int[] arr= {7,3,10,12,5,1,9,2};
		BinarySortTree binarysorttree =new BinarySortTree();
		for(int i=0;i<arr.length;i++)//添加节点到二叉树
		{
			binarysorttree.add(new Node(arr[i]));//细节处理呀
		}
		//中序遍历二叉排序树
		System.out.println("中序遍历二叉排序树");
		binarysorttree.infixOrder();//1,2,3,5,7,9,12
		
		//测试一下删除叶子结点
		binarysorttree.delNode(2);
		System.out.println("删除后");
		binarysorttree.infixOrder();
	}

}

class BinarySortTree{
	
	private Node root;
	//老规矩，继续把那两个查找方法封装过来
	public Node search(int value)
	{
		if(root==null)
		{
			return null;
		}
		else
		{
			return root.search(value);
		}
	}
	//查找父结点
	public Node searchParent(int value)
	{
		if(root==null)
		{
			return null;
		}
		else
		{
			return root.searchParent(value);
		}
	}
	//删除结点
	public void delNode(int value)
	{
		if(root==null)
		{
			return ;
		}
		else
		{
		//1.先找到要删除的结点
			Node targetNode=search(value);
			//如果没有找到要删除的结点
			if(targetNode==null)
			{
				return ;
			}
			//找要删除结点的父结点,如果二叉树只有一个结点(这时候删除的结点就没父结点）
			if(root.left==null&&root.right==null)
			{
				root=null;
				return ;
			}
			Node parent=searchParent(value);
			//如果要删除的结点是叶子结点
			if(targetNode.left==null&&targetNode.right==null)
			{
				//判断其是父结点的左子结点还是右子结点
				if(parent.left!=null&&parent.left.value==value)
				{
					parent.left=null;
				}else if(parent.right!=null&&parent.right.value==value)
				{
					parent.right=null;
				}
			}
		}	
	}
	//添加节点的方法
	public void add(Node node)
	{
		if(root==null)
		{
			root=node;;
		}
		else
		{
			root.add(node);
		}
	}
	public void infixOrder()
	{
		if(root!=null)
		{
			root.infixOrder();
		}
		else
		{
			System.out.println("二叉树排序树为空，不能遍历");
		}
	}
}


class Node{
	int value;
	Node left;
	Node right;
	public Node(int value)
	{
		this.value=value;
	}	
//查找要删除的结点
	public Node search(int value)
	{
		if(value==this.value)
		{
			return this;
		}
		else if(value <this.value)//向左递归查找
		{
			if(this.left==null)
			{
				return null;
			}
			return this.left.search(value);
		}else//如果不小于当前结点，向右子树递归
		{
			if(this.right==null)
			{
				return null;
			}
			return this.right.search(value);
		}
	}
	/**
	 * 
	 * @param value 要找的结点的值
	 * @return 返回的是要删除的结点的父结点，如果没有就返回null
	 */
	//查找要删除结点的父结点
	public Node searchParent(int value)
	{
		if((this.left!=null&&this.left.value==value)||(this.right!=null&&this.right.value==value))
			{
			return this;
			}
		else
		{
			//如果查找的值小于当前结点的值,并且当前结点的左子结点不为空
			if(value<this.value&&this.left!=null)
			{
				return this.left.searchParent(value);
			}
			else if(value>=this.value&&this.right!=null)
			{
				return this.right.searchParent(value);
			}else
			{
				return null;
			}
		}
		
	}
	
	 public String toString() {
		 return "Node[value="+value+"]"; 
		 }
	 
	//添加节点的方法
	//递归
	public void add(Node node)
	{
		if(node==null)
		{
			return ;
		}
		//判断传入节点的值和当前子树的根节点的值的关系
		if(node.value<this.value)
		{
			if(this.left==null)
			{
				this.left=node;//为空的话就搞上去
			}
			else
			{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else
		{
			if(this.right==null)
			{
				this.right=node;
			}else
			{//递归的向右子树添加，可以跟上面的联系去理解
				this.right.add(node);
			}
			
		}
	}
	//中序遍历
	public void infixOrder()
	{
		if(this.left!=null)
		{
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right!=null)
		{
			this.right.infixOrder();
		}
	}	
}

 

2.删除只有一颗子树的结点

  • 找到要删除的结点targetnode
  • 找到targetnode的父结点parent
  • 确定targetnode的子结点是左子结点还是右子结点
  • 确定targetnode是parent的左子结点还是右子结点
  • 如果targetnode有左子结点
  1. 如果targetnode是parent的左子结点  parent.left=targetnode.left;
  2. targetnode是parent的右子结点  parent.right=targetnode.left;
  • 如果targetnode有右子结点
  1. 如果targetnode是parent的左子结点  parent.left=targetnode.right;
  2. targetnode是parent的右子结点  parent.right=targetnode.right;

代码实现 

    主体代码    

else//删除只有一颗子树的结点
			{//如果要删除的结点有左子结点
				if(targetNode.left!=null)
				{
					if(parent!=null)
					{
					if(value==parent.left.value)//如果该删除结点是父结点的左子结点
					{
						parent.left=targetNode.left;
					}else//是父结点的右子结点
					{
						parent.right=targetNode.left;
					}
					}else
					{
						root=targetNode.left;
					}
				}else
				{
					if(parent!=null)
					{
					if(value==parent.left.value)//如果该删除结点是父结点的左子结点
					{
						parent.left=targetNode.right;
					}else//是父结点的右子结点
					{
						parent.right=targetNode.right;
					}
				}
					else
					{
						root=targetNode.right;
					}
				}	
				
			}

3.删除有两颗子树的结点

  • 找到要删除的结点targetnode
  • 找到targetnode的父结点parent
  • 从targetnode的右边找到最小的结点
  • 用一个临时变量，将最小结点的值保存 temp=12;
  • 删除该最小结点
  • targetnode.value=temp;

代码实现

主体代码

/**
	 * 
	 * @param node 传入的结点，当做二叉排序树的根结点
	 * @return 返回以node为根结点的二叉排序树的最小值,并且将其删除
	 */
	public int delrightmin(Node node)
	{
		Node target=node;
		//循环，找最小值
		while(target.left!=null)
		{
			target=target.left;
		}
		//这时target就指向了最小结点
		//删除最小结点
		delNode(target.value);
		return target.value;
	}
	
else if(targetNode.left!=null&&targetNode.right!=null)//删除有两颗子树的结点
			{
		
			int min=delrightmin(targetNode.right);
			targetNode.value=min;
			}

 数组移动数据慢，链表查找数据慢，二叉排序树的存在很好的弥补了这方面的缺点

总代码

package ka;

public class BST {
	
	public static void main(String[] args)
	{
		int[] arr= {7,3,10,12,5,1,9,2};
		BinarySortTree binarysorttree =new BinarySortTree();
		for(int i=0;i<arr.length;i++)//添加节点到二叉树
		{
			binarysorttree.add(new Node(arr[i]));//细节处理呀
		}
		//中序遍历二叉排序树
		System.out.println("中序遍历二叉排序树");
		binarysorttree.infixOrder();//1,2,3,5,7,9,12
		
		//测试一下删除叶子结点
		binarysorttree.delNode(7);
		System.out.println("删除后");
		binarysorttree.infixOrder();
	}

}

class BinarySortTree{
	
	private Node root;
	//老规矩，继续把那两个查找方法封装过来
	public Node search(int value)
	{
		if(root==null)
		{
			return null;
		}
		else
		{
			return root.search(value);
		}
	}
	//查找父结点
	public Node searchParent(int value)
	{
		if(root==null)
		{
			return null;
		}
		else
		{
			return root.searchParent(value);
		}
	}
	//编写方法
	/**
	 * 
	 * @param node 传入的结点，当做二叉排序树的根结点
	 * @return 返回以node为根结点的二叉排序树的最小值,并且将其删除
	 */
	public int delrightmin(Node node)
	{
		Node target=node;
		//循环，找最小值
		while(target.left!=null)
		{
			target=target.left;
		}
		//这时target就指向了最小结点
		//删除最小结点
		delNode(target.value);
		return target.value;
	}
	
	//删除结点
	public void delNode(int value)
	{
		if(root==null)
		{
			return ;
		}
		else
		{
		//1.先找到要删除的结点
			Node targetNode=search(value);
			//如果没有找到要删除的结点
			if(targetNode==null)
			{
				return ;
			}
			//找要删除结点的父结点,如果二叉树只有一个结点(这时候删除的结点就没父结点）
			if(root.left==null&&root.right==null)
			{
				root=null;
				return ;
			}
			Node parent=searchParent(value);
			//如果要删除的结点是叶子结点
			if(targetNode.left==null&&targetNode.right==null)
			{
				//判断其是父结点的左子结点还是右子结点
				if(parent.left!=null&&parent.left.value==value)
				{
					parent.left=null;
				}else if(parent.right!=null&&parent.right.value==value)
				{
					parent.right=null;
				}
			}
			else if(targetNode.left!=null&&targetNode.right!=null)//删除有两颗子树的结点
			{
		
			int min=delrightmin(targetNode.right);
			targetNode.value=min;
			}else//删除只有一颗子树的结点
			{//如果要删除的结点有左子结点
				if(targetNode.left!=null)
				{
					if(parent!=null)
					{
					if(value==parent.left.value)//如果该删除结点是父结点的左子结点
					{
						parent.left=targetNode.left;
					}else//是父结点的右子结点
					{
						parent.right=targetNode.left;
					}
					}else
					{
						root=targetNode.left;
					}
				}else
				{
					if(parent!=null)
					{
					if(value==parent.left.value)//如果该删除结点是父结点的左子结点
					{
						parent.left=targetNode.right;
					}else//是父结点的右子结点
					{
						parent.right=targetNode.right;
					}
				}
					else
					{
						root=targetNode.right;
					}
				}	
				
			}
		}	
	}
	//添加节点的方法
	public void add(Node node)
	{
		if(root==null)
		{
			root=node;;
		}
		else
		{
			root.add(node);
		}
	}
	public void infixOrder()
	{
		if(root!=null)
		{
			root.infixOrder();
		}
		else
		{
			System.out.println("二叉树排序树为空，不能遍历");
		}
	}
}


class Node{
	int value;
	Node left;
	Node right;
	public Node(int value)
	{
		this.value=value;
	}	
//查找要删除的结点
	public Node search(int value)
	{
		if(value==this.value)
		{
			return this;
		}
		else if(value <this.value)//向左递归查找
		{
			if(this.left==null)
			{
				return null;
			}
			return this.left.search(value);
		}else//如果不小于当前结点，向右子树递归
		{
			if(this.right==null)
			{
				return null;
			}
			return this.right.search(value);
		}
	}
	/**
	 * 
	 * @param value 要找的结点的值
	 * @return 返回的是要删除的结点的父结点，如果没有就返回null
	 */
	//查找要删除结点的父结点
	public Node searchParent(int value)
	{
		if((this.left!=null&&this.left.value==value)||(this.right!=null&&this.right.value==value))
			{
			return this;
			}
		else
		{
			//如果查找的值小于当前结点的值,并且当前结点的左子结点不为空
			if(value<this.value&&this.left!=null)
			{
				return this.left.searchParent(value);
			}
			else if(value>=this.value&&this.right!=null)
			{
				return this.right.searchParent(value);
			}else
			{
				return null;
			}
		}
		
	}
	
	 public String toString() {
		 return "Node[value="+value+"]"; 
		 }
	 
	//添加节点的方法
	//递归
	public void add(Node node)
	{
		if(node==null)
		{
			return ;
		}
		//判断传入节点的值和当前子树的根节点的值的关系
		if(node.value<this.value)
		{
			if(this.left==null)
			{
				this.left=node;//为空的话就搞上去
			}
			else
			{
				//递归的向左子树添加
				this.left.add(node);
			}
		}else
		{
			if(this.right==null)
			{
				this.right=node;
			}else
			{//递归的向右子树添加，可以跟上面的联系去理解
				this.right.add(node);
			}
			
		}
	}
	//中序遍历
	public void infixOrder()
	{
		if(this.left!=null)
		{
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right!=null)
		{
			this.right.infixOrder();
		}
	}	
}

学习如逆水行舟，不进则退。和小吴一起加油吧！

小吴有想法
关注
  • 17
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 18
    评论
专栏目录
二叉搜索树
HHHuYYYue的博客
05-29 1208
一. 什么是二叉搜索树? 二叉搜索树是一棵特殊的二叉树, 又称为二叉排序树, 其特性为: 空树也是二叉搜索树 若它的左子树不为空, 则左子树上所有节点值均小于根节点的值 若它的右子树不为空, 则右子树上所有节点值均大于根节点的值 二叉搜索树的左右子树也都是二叉搜索树 二叉搜索树通过中序遍历可以得到一个有序的序列 例如上图中, 中序遍历的结果为: 2 3 3 7 8 9 10 12 16 18 二. 关于二叉搜索树的操作 1. 增加一个节点 根据二叉搜索树的性质, 增加节点的思路如下: 假设在这棵二叉
二叉排序树（BST）笔记
爪哇岛民工的博客
07-19 197
什么是二叉排序树 二叉排序树中的每一个节点，其值大于左子树的所有节点的值，小于右子树所有节点的值。 【7,3,10,12,5,1,9,2】数组组成的BST 二叉排序树的查询效率很高，下面是一些关于二叉排序树实现的方法。 节点信息 class Node { private int val; Node left; Node right; public int getVal() { return val; } public void setVa
二叉排序树BST实现笔记
qq_26239785的博客
08-13 316
题目链接 acwing3786 代码 #include<iostream> using namespace std; const int INF=0x3f3f3f3f; struct treenode { int val; treenode *left,*right; treenode(int _val) :val(_val),left(NULL),right(NULL){} }; treenode *root; void insert(treenode *&r
二叉查找树（BST）（算法笔记）
Arabot_的博客
04-10 571
数据结构的目的是用来优化数据的使用效率，这是数据结构的本质。二叉查找树是一种特殊形态的二叉树，又称为排序二叉树、二叉搜索树、二叉排序树。对树上的每个节点，都满足其左子树上所有结点的数据域均小于或等于根节点的数据域，右子树上所有结点的数据域均大于根结点的数据域。单独使用一颗普通的二叉树对提高数据使用效率没有太大帮助，因为普通二叉树数据之间不存在明显的逻辑联系，在进行插入时，无法提供性质满足插入位置的确定，即插入位置的选择完全是随机的，所以并不会直接考察普通二叉树的插入和删除操作。
二叉排序树插入相同值的处理
热门推荐
qq_38608897的博客
01-04 2万+
二叉排序树插入相同值的处理什么是二叉排序树二叉排序树建立（插入）出现相同值的处理 什么是二叉排序树 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有下列性质的二叉树： （1）若左子树不为空，则左子树上所有结点的值均小于它的根节点的值 （2）若右子树不为空，则右子树上所有结点的值均大于它的根节点的值 （3）左右子树自己也是二叉排序树 二叉排序树建立（插入）出现相同值的处理 一...
算法笔记，将有序数组转为二叉搜索树
03-19
给定一个整数数组 nums，其中元素已经按升序进行了排序，请将其转换为一棵高度平衡的二叉搜索树。高度平衡二叉树是一棵满足每个节点的左右两个子树的高度差的绝对值不超过 1 的二叉树。 解题思路 为了解决这个问题...
算法笔记，有序链表转为二叉搜索树
03-19
这个问题的目标是利用已排序的链表数据，构建一棵二叉搜索树（BST），使得这棵树在保持二叉搜索树特性的同时，还能尽可能地平衡，即左右子树的高度差不超过1。这种树被称为高度平衡二叉搜索树。 **二叉搜索树的定义...
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归...斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等...
数据结构笔记
10-10
二叉树的类型包括二叉查找树（BST）、完全二叉树、满二叉树等。二叉树操作如查找、插入和删除都有其特定的时间复杂度，如在平衡的二叉查找树中，这些操作的时间复杂度为O(log n)。 3. **栈与队列**：栈是一种后进先...
C程序数据结构专用笔记
06-20
5. **树结构**：二叉树是最常见的树形数据结构，包括二叉查找树（BST）、平衡树（AVL、红黑树等）等，它们在搜索、排序等领域有广泛应用。此外，还有多路查找树、B树和B+树等高级数据结构。 6. **图**：图是由节点...
二叉树整理2
m0_47296354的博客
03-01 878
1.求N叉树最大深度
排序二叉树的建立注意重复元素
BlessingXRY的博客
02-08 8089
think： 1建立排序二叉树时 注意重复元素 sdut原题链接 树结构练习——排序二叉树的中序遍历 Time Limit: 1000MS Memory Limit: 65536KBProblem Description 在树结构中，有一种特殊的二叉树叫做排序二叉树，直观的理解就是——(1).每个节点中包含有一个关键值 (2).任意一个节点的左子树（如果存在的话）的关键值小于该节点的关键值
二叉查找树（重复元素情况）
weixin_53700782的博客
06-02 2051
查找排序数组中的第一个元素与最后一个元素
二叉查找树基本实现和对重复数据的处理以及优化成为平衡二叉树
qq_41800087的博客
04-29 5456
1 二叉排序树概念 二叉查找树 又叫 二叉排序树，二叉搜索树。Binary Search Tree(BST) 对于二叉查找树中的每一个节点如果存在左节点，左节点的值一定小于该节点的值 对于二叉查找树中的每一个节点如果存在右节点，右节点的值一定大于该节点的值 也就是说对于二叉查找树中的任何一个非叶子节点，左节点值小于当前节点值，右节点值大于当前节点值 二叉查找树的任何一个非叶子节点的左子树...
二叉查找树-增删查和针对重复数据处理的 Java 实现
多选参数
07-29 744
0. 前言大家好，我是多选参数的程序锅，一个正在”研究“操作系统、学数据结构和算法以及 Java 的疯狂猛补生。本篇将带来的是二叉查找树的相关知识，知识提纲如图所示。另外由于极客时间的《...
二叉树
张花生的博客
09-24 780
目录   二叉树 什么是二叉树？ 什么是二叉排序树？ 二叉树的数据结构定义 二叉树的各种遍历 从上到下不分行的层序遍历 从底到上分行的层序遍历 二叉树的最小深度 判断是否为平衡二叉树 按之字形打印二叉树 二叉树的直径 二叉树的镜像 判断是否为对称二叉树 二叉树 什么是二叉树？ 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”和“右子...
二叉排序树(查找树、搜索树)
webor2006的博客
09-23 323
在上一次https://www.cnblogs.com/webor2006/p/11530008.html中对二叉树进行了简单的入门，对于上节涉及到的树实用性倒不是太大，但是从今天开始接触的二叉树都是比较有实用价值的，像在JDK8之后很多的结构也都使用到了树，所以学好树是非常有必要的。 二叉排序树开端： 先来看一张二叉排序树的图： 它或者是一颗空树，或者是一颗具有如下性质的树： 1)若左子树不...
如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树
喝泉水的泉
11-18 651
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { public boolean isUnivalTree(TreeNode root) { r...
二叉排序树BST的查找
最新发布
11-03
二叉排序树BST的查找可以分为两种情况：一种是查找成功，一种是查找失败。查找成功的情况是指在BST中找到了目标值，查找失败的情况是指在BST中没有找到目标值。 查找成功的情况下，可以直接返回该节点；查找失败的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小吴有想法

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值