树形数据结构——ClosureTable

最新推荐文章于 2024-03-11 16:38:13 发布
最新推荐文章于 2024-03-11 16:38:13 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 树形数据结构 ClosureTable
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZZY1078689276/article/details/99587901
版权
本文介绍了在项目开发中常见的树形数据结构——ClosureTable，并提供了实现细节和测试结果。作者通过阅读相关博文，对手写ClosureTable有了深入理解，并分享了完整的源码和测试案例，所有代码已经通过测试。
摘要由CSDN通过智能技术生成

文章目录

思想来源

  在现实的项目开发中，我们经常会用到树形数据结构，对于什么是树形数据结构，具体可以参考如下的两篇博文：

  在看完上面两篇博文的基础上，我们就对树形数据结构，尤其是对ClosureTable有了更加清晰的认识，既然项目中经常会用到该树形数据结构，那么我们就有必要手写一个实现版本。

源码

文件目录结构

在这里插入图片描述

项目源码

  pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
  </parent>

  <groupId>com.lyc</groupId>
  <artifactId>closure-table</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>closure-table</name>
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
    <spring-cloud.version>Greenwich.SR1</spring-cloud.version>
  </properties>

  <dependencyManagement>
    <dependencies>
      <!-- SpringCloud版本 -->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${spring-cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

  <dependencies>
    <!-- SpringBoot Web依赖 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 测试依赖 -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <!-- lombok依赖 -->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.8</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>

  <build>
    <finalName>${project.artifactId}</finalName>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

  AncestorSequence

package com.lyc.closure.closureTable.core.ancestor;

import com.lyc.closure.closureTable.core.Node;
import com.lyc.closure.closureTable.core.entity.NodeArray;

/**
 * @author: 张侦毅
 * @date: 2019/6/16 9:58
 * @description: 祖先接口
 **/
public interface AncestorSequence {
   

    // 节点数组指针的初始化
    boolean init(Node ele);
    // 加载节点数组指针域
    boolean loadNodeArray(Node ele);
    // 获取NodeArray对象
    NodeArray getNodeArray();
    // 获取当前节点数组
    Node[] getCurrentNodeArray();
    // 获取目标节点中的节点数组
    Node[] getNodeArray(Node ele);
    // 拷贝目标节点中的节点数组
    Node[] copyNodeArray(Node ele);
    // 设置节点中的节点数组指针域
    boolean setNodeArray(Node[] nodeArray, Node ele);
    // 写入节点中的节点数组指针域
    boolean writeNodeArray(Node ele);
    // 节点数组指针的判空
    boolean isEmpty();
    // 获取节点数组指针的长度
    int length();
    // 获取节点数组指针指定位置处的元素
    boolean getEle(int index, Node ele);
    // 返回第一个满足ele的数据元素的位置
    int locateEle(Node data);
    // 获取节点数组指针指定元素的前驱
    boolean priorEle(Node currentEle, Node preEle);
    // 获取节点数组指针指定元素的后继
    boolean nextEle(Node currentEle, Node nextEle);
    // 节点数组指针的数据添加（在最后添加）
    boolean insert(Node ele);
    // 节点数组指针的数据添加
    boolean insert(int index, Node ele);
    // 节点数组指针的数据删除（删除尾结点）
    boolean delete();
    // 节点数组指针的数据删除
    boolean delete(int index, Node pNode);
    // 节点数组指针的数据遍历
    void traverse();
    // 节点数组扩容
    boolean dilatation();
    // 节点数据深拷贝
    boolean cope(Node current, Node target);

}

  AncestorSequenceImpl

package com.lyc.closure.closureTable.core.ancestor;

import com.lyc.closure.closureTable.core.Node;
import com.lyc.closure.common.ClosureCommonConstant;
import com.lyc.closure.closureTable.core.entity.NodeArray;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;

import java.util.Arrays;

/**
 * @author: 张侦毅
 * @date: 2019/6/16 9:59
 * @description: 祖先接口实现类
 **/
@Slf4j
@Getter
@Setter
@NoArgsConstructor
public class AncestorSequenceImpl implements AncestorSequence{
   

    // 节点数组指针域
    private NodeArray nodeArray = null;
    // 初始化节点数组
    private static final Node[] INIT_NODE_ARRAY = new Node[ClosureCommonConstant.Closure.INIT_CAPACITY];

    /**
     * 节点数组指针的初始化
     * @param ele 节点
     * @return boolean
     */
    @Override
    public boolean init(Node ele) {
   
        // 如果节点不为空，则初始化节点数组，同时初始化节点的节点数组指针域
        if(ele != null){
   
            // 创建父辈路径节点数组
            NodeArray ancestors = NodeArray.builder()
                    .size(ClosureCommonConstant.Closure.INIT_CAPACITY)
                    .pList(INIT_NODE_ARRAY)
                    .iLength(ClosureCommonConstant.Closure.INIT_DATA_LENGTH)
                    .build();
            // 将创建的父辈路径节点数组添加到父辈节点域中
            ele.setAncestors(ancestors);
            // 加载Node对象中的NodeArray对象到NodeArrayCoreImpl的nodeArray中
            loadNodeArray(ele);
            return true;
        }
        return false;
    }

    /**
     * 加载节点数组指针域，如果成功，则返回true，失败则返回false
     * @param ele 目标节点
     * @return boolean
     */
    @Override
    public boolean loadNodeArray(Node ele) {
   
        if(ele != null){
   
            this.nodeArray = ele.getAncestors();
            return true;
        }
        return false;
    }

    /**
     * 获取当前节点数组
     * @return Node[]
     */
    @Override
    public Node[] getCurrentNodeArray() {
   
        return this.nodeArray.getPList();
    }

    /**
     * 获取目标节点中的节点数组
     * @param ele 目标节点
     * @return Node[]
     */
    @Override
    public Node[] getNodeArray(Node ele) {
   
        // 如果节点不为空，则返回节点中的节点数组指针域
        if(ele != null){
   
            return ele.getAncestors().getPList();
        }
        return null;
    }

    /**
     * 拷贝目标节点中的节点数组
     * @param ele 目标节点
     * @return Node[]
     */
    @Override
    public Node[] copyNodeArray(Node ele) {
   
        // 如果节点不为空，则返回节点中的节点数组指针域
        if(ele != null){
   
            // 获取NodeArray容器
            Node[] nodeArrayContainer = ele.getAncestors().getPList();
            // 从容器中复制有效数据，并返回
            return Arrays.copyOf(nodeArrayContainer,ele.getAncestors().getILength());
        }
        return null;
    }

    /**
     * 设置节点中的节点数组指针域
     * @param nodeArray 节点数组指针域
     * @param ele 目标节点
     * @return boolean
     */
    @Override
    public boolean setNodeArray(Node[] nodeArray,Node ele) {
   
        // 如果当前节点数组指针域与目标节点均不为空，则执行赋值操作
        if(nodeArray != null && ele != null){
   
            ele.getAncestors().setPList(nodeArray);
            return true;
        }
        return false;
    }

    /**
     * 写入节点中的节点数组指针域
     * @param ele 节点数组指针域
     * @return boolean
     */
    @Override
    public boolean writeNodeArray(Node ele) {
   
        // 如果不为空，则将节点数组指针域回写到当前节点中
        if(ele != null){
   
            ele.setAncestors(this.getNodeArray());
            return true;
        }
        return false;
    }

    /**
     * 节点数组指针的判空
     * @return boolean
     */
    @Override
    public boolean isEmpty() {
   
        if(this.nodeArray != null && this.nodeArray.getILength() == 0){
   
            return true;
        }
        return false;
    }

    /**
     * 获取节点数组指针的长度
     * @return int
     */
    @Override
    public int length() {
   
        if(this.nodeArray != null){
   
            return this.nodeArray.getILength();
        }
        return 0;
    }

    /**
     * 获取节点数组指针指定位置处的元素
     * @param index 节点的索引值
     * @param ele 获取的元素
     * @return boolean
     */
    @Override
    public boolean getEle(int index, Node ele) {
   
        // 如果数据在有效范围内
        if(index >= 0 && index < this.nodeArray.getILength()){
   
            // 则取出相应的元素直接赋值给ele，传出
            // 获取目标节点
            Node temp = this.nodeArray.getPList()[index];
            // 数据拷贝
            cope(temp,ele);
            // 获取成功后返回成功状态
            return true;
        }
        return false;
    }

    /**
     * 返回第一个满足ele的数据元素的位序
     * @param ele 目标节点
     * @return int
     */
    @Override
    public int locateEle(Node ele) {
   
        // 如果目标节点存在
        if(ele != null){
   
            // 获取节点数组指针域
            Node[] pList = this.nodeArray.getPList();
            // 获取节点数组的长度
            int length = this.nodeArray.getILength();
            // 循环遍历，依次查找比对节点的数据域
            for(int i = 0; i < length; i ++){
   
                // 如果当前节点的数据域与目标节点的数据域相同，则返回当前节点所在的位序
                if(pList[i].getData() == ele.getData()){
   
                    return i;
                }
            }
        }
        // 如果查找不到，则返回位序值为-1
        return -1;
    }

    /**
     * 获取节点数组指针指定元素的前驱
     * @param currentEle 当前节点
     * @param preEle 前一个节点
     * @return boolean
     */
    @Override
    public boolean priorEle(Node currentEle, Node preEle) {
   
        // 获取当前元素所在的位序
        int temp = locateEle(currentEle);
        // 如果在有效范围内
        if(temp > 0){
      // 第一个元素没有前驱
            // 获取前驱节点
            Node temp2 = this.nodeArray.getPList()[temp - 1];
            // 数据拷贝
            cope(temp2,preEle);
            // 前驱节点获取成功后返回true
            return true;
        }
        return false;
    }

    /**
     * 获取节点数组指针指定元素的后继
     * @param currentEle 当前元素
     * @param nextEle 指定元素的后继
     * @return boolean
     */
    @Override
    public boolean nextEle(Node currentEle, Node nextEle) {
   
        // 获取当前元素所在的位序
        int temp = locateEle(currentEle);
        // 如果在有效范围内
        if(temp != -1 && temp < this.nodeArray.getILength() -1){
   
            // 获取后继节点
            Node temp2 = this.nodeArray.getPList()[temp + 1];
            // 数据拷贝
            cope(temp2,nextEle);
            // 获取后继点解成功后返回true
            return true;
        }
        return false;
    }

    /**
     * 节点数组指针的数据添加（在最后添加）
     * @param ele 目标元素
     * @return boolean
     */
    @Override
    public boolean insert(Node ele) {
   
        // 获取节点数组的长度
        int length = length();
        // 如果数据在有效范围内
        if(length < this.nodeArray.getSize()){
   
            // 运行扩容方法（不一定会扩容）
            dilatation();
            // 将传入节点插入到节点数组中（尾端插入）
            this.nodeArray.getPList()[length] = ele;
            // 添加完成之后，长度自增1
            this.nodeArray.setILength(this.nodeArray.getILength() + 1);
            return true;
        }
        // 执行插入操作
        return false;
    }

    /**
     * 节点数组指针的数据添加
     * @param index 索引值
     * @param ele 目标元素
     * @return boolean
     */
    @Override
    public boolean insert(int index, Node ele) {
   
        // 如果插入点在有效范围内
        if(index > 0 && index < this.nodeArray.getSize() - 1){
   
            // 运行扩容方法（不一定会扩容）
            dilatation();
            // 将传入节点插入到节点数组中（非尾端插入，需要移动节点）
            // 先获取节点数组
            Node[] pList = this.nodeArray.getPList();
            for(int k = this.nodeArray.getILength() - 1; k >= index; k --){
   
                // 把当前元素向后移动一位
                pList[k + 1] = pList[k];
            }
            // 将目标元素插入到目标位序
            pList[index] = ele;
            // 将数据长度+1
            this.nodeArray.setILength(this.nodeArray.getILength() + 1);
            return true;
        }
        return false;
    }

    /**
     * 节点数组指针的数据删除（删除尾结点）
     * @return boolean
     */
    @Override
    public boolean delete() {
   
        // 如果数据在有效长度范围内
        if(this.nodeArray.getILength() > 0){
      // 保证数组容器内至少有一个节点
            // 删除尾结点（采用逻辑删除即可）
            this.nodeArray.setILength(this.nodeArray.getILength() - 1);
        }
        return false;
    }

    /**
     * 节点数组指针的数据删除
     * @param index 目标节点位序
     * @param pNode 目标节点
     * @return boolean
     */
    @Override
    public boolean delete(int index, Node pNode) {
   
        // 如果数据在有效范围内
        if(index > -1 && index <= this.nodeArray.getILength() - 1){
   
            // 获取节点数组
            Node[] pList = this.nodeArray.getPList();
            // 获取指定位置处的节点
            getEle(index,pNode);
            // 循环遍历，向左移动数组
            for(int k = index + 1; k < this.nodeArray.getILength(); k ++){
   
                // 后一个元素向左移动一个元素
                pList[index] = pList[k];
            }
            // 节点数组长度自减1
            this.nodeArray.setILength(this.nodeArray.getILength() - 1);
            return true;
        }
        return false;
    }

    /**
     * 节点数组指针的数据遍历
     */
    @Override
    public void traverse() {
   
        // 获取节点数组
        Node[] pList = this.nodeArray.getPList();
        // 获取节点数组长度
        int length = this.nodeArray.getILength();
        // 如果节点数组不为空
        if(length > 0){
   
            // 循环遍历所有的数据
            for(int i = 0; i < length; i ++) {
   
                // 在控制台中打印节点数组
                log.info(pList[i].getData().toString());
            }
        }
    }

    /**
     * 节点数组扩容
     * @return boolean
     */
    @Override
    public boolean dilatation() {
   
        // 如果达到加载因子上限，则执行扩容操作
        if(this.nodeArray.getILength() >= (this.nodeArray.getSize() * ClosureCommonConstant.Closure.DEFAULT_LOAD_FACTOR)){
   
            // 生成新的容器容量
            int capacity = this.nodeArray.getSize() << 1;
            // 生成新的节点数组
            Node[] pList = Arrays.copyOf(this.nodeArray.getPList(),capacity);
            // 将新的节点数组回写到当前节点的节点数组指针域中
            this.nodeArray.setPList(pList);
            // 将容器的容量设置为新的数值
            this.nodeArray.setSize(capacity);
            // 扩容成功后，返回true
            return true;
        }
        return false;
    }

    /**
     * 节点数据深拷贝
     * @param current 当前节点
     * @param target 目标节点
     * @return boolean
     */
    @Override
    public boolean cope(Node current, Node target) {
   
        if(current != null && target != null){
   
            // 执行数据拷贝
            BeanUtils.copyProperties(current,target)<
最低0.47元/天 解锁文章
张侦毅
关注
专栏目录
ClosureTable：Laravel框架的邻接表的Closure Table数据库设计模式实现
02-02
封闭表 这是Laravel 5.4+框架的数据库操作包。 当您需要在数据库中存储和操作分层数据时，可能需要使用它。 该软件包是一种称为的著名设计模式的实现。 但是，为了简化和优化SQL SELECT查询，它使用邻接表来查询直接的父/子关系。 内容： 示例→ 示例→ 示例→ 范例→ 范例→ 例子→ 示例→ 示例→ 安装 强烈建议使用安装该软件包： $ composer require franzose/closure-table 如果您使用Laravel 5.5+，则借助功能，可以自动为您注册软件包的服务提供商。 否则，您必须手动将其添加到config/app.php ： <?php return [ 'providers' => [ Franzose \ ClosureTable \ ClosureTableServiceProvider ::class ] ]; 建立 在基本情况下，您可以简单地运行以下命令： $ php artisan closuretable:make Node 其中Node是实体模型的名称。 这是通过运行以上命令得到
树状结构数据的数据库表设计及使用 - 3. 闭包表（Closure Table）模型
不吃_花椒的博客
06-22 6290
本文以 MySQL 为例。文档比较长，故分为5部分发出： 闭包表模型 闭包表（Closure Table）是一种通过空间换时间的模型，它是用一个专门的关系表（其实这也是我们推荐的归一化方式）来记录树上节点之间的层级关系以及距离。 为了防止插入数据出错，我们需要一个存储过程： 然后我们插入一些数据，这里以在论坛里发帖回帖为例： 前面的存储过程会在关系表里插入每条贴子与自身和它上级贴子的关系以及距离： 获取闭包表全树或子树 通过关联表的父子关系，去掉自指的记录，使用内连接获取所有子节点。 叶节点的特征是没有
nestjs[typeorm学习之实体(entity)与数据表的探究]
墨水白云的博客
11-27 5416
nestjs[typeorm学习之entity与数据库中表的关系]
ClosureTable实现高效无限分类
weixin_34195364的博客
04-19 967
ClosureTable直译过来叫闭包表？不过不重要，ClosureTable以一张表存储节点之间的关系、其中包含了任何两个有关系（上下级）节点的关联信息 ClosureTable演示 定义关系表CategoryTree，其包含3个字段： ancestor 祖先：上级节点的iddescendant 子代：下级节点的iddistance 距离：子代到祖先中间隔了几级 这三个字段的组合是唯一的...
在数据库中存储一棵树，实现无限级分类
weixin_34239169的博客
04-10 1028
原文发表于我的博客： https://blog.kaciras.net/article/36 在一些系统中，对内容进行分类是必需的功能。比如电商就需要对商品做分类处理，以便于客户搜索；论坛也会分为很多板块；门户网站、也得对网站的内容做各种分类。 分类对于一个内容展示系统来说是不可缺少的，本博客也需要这么一个功能。众所周知，分类往往具有从属...
C语言数据结构——树
01-10
C语言数据结构，树相关知识，整理了一段时间，差不多有个雏形，大家可以参考学习。
自定义数据结构——树 v1.1.zip
06-03
实现了一个自定义的数据结构 —— 树，该自定义结构不同于二叉树及其他数据结构，每个节点的子节点个数不受限制，最大限度保留了数据的原始结构，并实现了其前序和后序遍历的方法。优点是节省了内存，但缺点则是基于...
数据结构——————KMP算法
03-12
数据结构——————KMP算法
数据结构——队列 求队列长度 C语言
03-16
输入若干个整数, 以0结束, 利用入队的操作生成一个循环队列, 求该队列的长度。
优雅的对树形结构进行高性能分页，闭包表才是yyds
方志朋的博客
03-04 483
一、定义的概述闭包表（Closure Table）是一种用于存储和查询树形数据结构的技术，它通过在关系表中记录树节点之间的直接和间接关系来表示节点之间的层次结构。闭包表的设计目的是支持高效的树遍历和查询操作。二、闭包表的特点闭包表通常是一个包含两个主要列的表：祖先列和后代列。每一行记录都表示一对节点之间的关系，其中祖先列存储父节点（或祖先节点）的标识，后代列存储子节点（或后代节点）的标识。通过在闭...
闭包表（Closure Table）存储和查询树形数据结构
最新发布
usa_washington的博客
03-11 1171
树形结构数据 闭包表Closure Table
Eggjs -typeorm 之 TreeEntity 实战
原小明
04-20 4831
Tree - Entitiy 教程地址 https://typeorm.io/#/tree-entities 案例 场景：分组设计、树设计、菜单设计 树结构 , 括号里是存储的 ID - 华北(11) - 河南(14) - 郑州(17) - 焦作(18) - 河北(15) - 太原(19) - 华南(12) - 西南(13) ...
MySQL数据库闭包 Closure Table 表实现
漫游游的博客
12-27 1684
像MySQL这样的关系型数据库，比较适合存储一些类似表格的扁平化数据，但是遇到像树形结构这样有深度的数据，就很难驾驭了。针对这种场景，闭包表（Closure Table ）是最通用的设计，它要求一张额外的表来存储关系，使用空间换时间的方案减少操作过程中由冗余的计算所造成的消耗。闭包表，它记录了树中所有节点的关系，不仅仅只是直接父子关系，它需要使用两张表，除了节点表本身之外，还需要使用一张关系表，用来存储祖先节点和后代节点之间的关系（同时增加一行节点指向自身）,并且根据需要，可以增加一个字段，表示深度。
Closure Table-树形多级关系数据库设计(MySql)
a123_z的博客
07-31 932
一般树形多级关系数据库设计，比较普遍的就是四种方法：（具体见 SQL Anti-patterns这本书） Adjacency List：每一条记录存parent_id Path Enumerations：每一条记录存整个tree path经过的node枚举（适合深度较浅且固定的业务，字段超长互后将无法命中索引） Nested Sets：每一条记录存 nleft 和 nright Closure Table：维护一个表，所有的tree path作为记录进行保存。 本文将以Adjacency List
bootstrap-table + treegrid 实现树形表格
qq_21223653的博客
05-27 869
实现一个树形表格的时候有多种方法：比如把 ztree 的树形直接拼接成表格，或者用强大的 jqgrid 实现，今天介绍一个比较轻量级的实现：使用bootstrap-table + treegrid 。 引入 jquery.js、bootstrap-table.js、bootstrap-table-treegrid.js、jquery.treegrid.js 以及相应的 css 文件：bootstrap.css、bootstrap-table.css、jquery.treegrid.css； 后台传到前台的
关于vxetable的树状结构以及数组结构以及进行分组
m0_59638694的博客
10-26 2794
关于vxetable处理完数据(数组结构)并不能展示成树结构的问题
table-tree 表格树、树形数据处理、数据转树形数据
dinghuoruo0011的博客
04-11 3531
前言 公司想搞个表格树的展示页面，看着element有个表格树，还以为可以用。 用出来只用表格没有树，研究半天没研究个所以然，只能从新找个 npm里找到一个：vue-table-with-tree-grid 正文 element的坑 element：http://element-cn.eleme.io/#/zh-CN/component/table ...
基于Vue + element制作扁平化树形结构渲染表格（动态行列合并，树结构算法应用）
m0_49083276的博客
09-15 2406
1）扁平转树和树形转扁平，element-ui的表格组件从数组索引0开始渲染一直到最后，如果后端没有按照顺序传数据会导致表格错乱，所以我们需要将数据二次处理（扁平转树再转扁平），达到整理数据的效果//扁平转树if (!} else {});} else {});},//树转扁平// 将当前节点添加到结果数组中// 递归遍历子节点// 从每个根节点开始遍历},//重构数据},
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值