树：二叉排序树

最新推荐文章于 2023-01-02 20:18:13 发布
最新推荐文章于 2023-01-02 20:18:13 发布
阅读量284 收藏
点赞数
分类专栏： 数据结构&算法 文章标签： 数据结构 算法 树 二叉树 二叉排序树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011976388/article/details/107434740
版权

1，二叉树基本概念

  • 树分为很多种，其中每一个节点最多有两个节点的树形式称之为二叉树
  • 二叉树的子节点分为左节点和父节点；对于一个父节点来说，可以单独存在左子节点或者右子节点，也可以同时存在左右子节点
    在这里插入图片描述
  • 如果二叉树的所有叶子节点都在最后一层，并且节点总数 = 2 ^ n - 1，n为最大层数，则该二叉树可以称之为满二叉树
    在这里插入图片描述
  • 如果二叉树的所有叶子节点都在最后一层或者倒数第二层，且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，则称之为完全二叉树
    在这里插入图片描述

2，二叉树遍历

2.1，前序遍历

  • 先输出当前节点（初始为叶子节点）
  • 如果左子节点不为空，再递归前序遍历输出左子节点
  • 如果右子节点不为空，最后递归前序遍历输出右子节点

2.2，中序遍历

  • 如果左子节点不为空，先递归中序遍历输出左子节点
  • 再输出当前节点
  • 如果右子节点不为空，最后递归中序遍历输出右子节点

2.3，后续遍历

  • 如果左子节点不为空，先递归后序遍历输出左子节点
  • 如果右子节点不为空，再递归后序遍历输出右子节点
  • 最后输出当前节点

2.4，遍历代码汇总

package com.self.datastructure.tree;

import lombok.Data;
import lombok.ToString;

import java.util.ArrayList;
import java.util.List;

/**
 * 二叉树
 *
 * @author pj_zhang
 * @create 2020-03-21 22:02
 **/
public class BinaryTree {

    public static void main(String[] args) {
        MyBinaryTree binaryTree = new MyBinaryTree();
        binaryTree.addNode(5);
        binaryTree.addNode(1);
        binaryTree.addNode(4);
        binaryTree.addNode(6);
        binaryTree.addNode(3);
        binaryTree.addNode(2);
        binaryTree.addNode(7);
        binaryTree.addNode(8);
        binaryTree.addNode(8);
        binaryTree.postShowDetails(binaryTree.getNode());
    }

    static class MyBinaryTree {

        private Node node;

        // 添加二叉树节点
        public void addNode(Integer data) {
            if (null == node) {
                node = new Node(data);
            } else {
                addNode(data, node);
            }
        }

        private void addNode(Integer data, Node node) {
            if (null == node) {
                throw new RuntimeException("Node 节点为空");
            }
            if (data > node.getData()) {
                Node rightNode = node.getRightNode();
                if (null == rightNode) {
                    Node newNode = new Node(data);
                    node.setRightNode(newNode);
                    newNode.setParentNode(node);
                } else {
                    addNode(data, node.getRightNode());
                }
            } else if (data < node.getData()) {
                Node leftNode = node.getLeftNode();
                if (null == leftNode) {
                    Node newNode = new Node(data);
                    node.setLeftNode(newNode);
                    newNode.setParentNode(node);
                } else {
                    addNode(data, node.getLeftNode());
                }
            } else {
                System.out.println("数据节点已经存在");
            }
        }

        // 获取整体树节点
        public Node getNode() {
            return node;
        }

        // 前序遍历,
        // 先输出当前节点值
        // 再输出左侧节点值
        // 最后输出右侧节点值
        public void preShowDetails() {
            doPreShowDetails(node);
        }

        private void doPreShowDetails(Node node) {
            if (null == node) {
                return;
            }
            System.out.println("Node: " + node.getData());
            if (null != node.getLeftNode()) {
                doPreShowDetails(node.getLeftNode());
            }
            if (null != node.getRightNode()) {
                doPreShowDetails(node.getRightNode());
            }
        }

        // 中序输入
        // 先输出左侧节点值
        // 再输出当前节点值
        // 最后输出中间节点值
        // 中序输出结果为有序数组
        public void middleShowDetails() {
            doMiddleShowDetails(node);
        }

        public void doMiddleShowDetails(Node node) {
            if (null == node) {
                return;
            }
            if (null != node.getLeftNode()) {
                doMiddleShowDetails(node.getLeftNode());
            }
            System.out.println("Node: " + node.getData());
            if (null != node.getRightNode()) {
                doMiddleShowDetails(node.getRightNode());
            }
        }

        // 后续输出
        // 先输出左侧数据
        // 再输出右侧数据
        // 最后输出当前数据
        public void postShowDetails() {
            doPostShowDetails(node);
        }

        public void doPostShowDetails(Node node) {
            if (null == node) {
                return;
            }
            if (null != node.getLeftNode()) {
                doPostShowDetails(node.getLeftNode());
            }
            if (null != node.getRightNode()) {
                doPostShowDetails(node.getRightNode());
            }
            System.out.println("Node: " + node.getData());
        }

    }

    @Data
    @ToString
    static class Node {

        private Integer data;

        private Node leftNode;

        private Node rightNode;
		
		private Node parentNode;

        public Node() {}

        public Node(Integer data) {
            this(data, null, null);
        }

        public Node(Integer data, Node leftNode, Node rightNode) {
            this.data = data;
            this.leftNode = leftNode;
            this.rightNode = rightNode;
        }

    }
}

3，二叉树查找

3.1，前序查找

  • 先比较当前节点，当前节点匹配到直接返回
  • 再匹配左侧节点，并递归前序查找进行匹配，匹配到直接返回
  • 最后匹配右侧节点，并递归前序查找进行匹配，匹配到直接返回
  • 以上几步没有匹配到，则返回null，表示没有匹配到

3.2，中序查找

  • 先匹配左侧节点，并递归中序查找进行匹配，匹配到直接返回
  • 再比较当前节点，当前节点匹配到直接返回
  • 最后匹配右侧节点，并递归中序查找进行匹配，匹配到直接返回
  • 以上几步没有匹配到，则返回null，表示没有匹配到

3.3，后续查找

  • 先匹配左侧节点，并递归后序查找进行匹配，匹配到直接返回
  • 再匹配右侧节点，并递归后序查找进行匹配，匹配到直接返回
  • 再比较当前节点，当前节点匹配到直接返回
  • 以上几步没有匹配到，则返回null，表示没有匹配到

3.4，查找代码汇总

package com.self.datastructure.tree;

import lombok.Data;
import lombok.ToString;

import java.util.ArrayList;
import java.util.List;

/**
 * 二叉树
 *
 * @author pj_zhang
 * @create 2020-03-21 22:02
 **/
public class BinaryTree {

    public static void main(String[] args) {
        MyBinaryTree binaryTree = new MyBinaryTree();
        binaryTree.addNode(5);
        binaryTree.addNode(1);
        binaryTree.addNode(4);
        binaryTree.addNode(6);
        binaryTree.addNode(3);
        binaryTree.addNode(2);
        binaryTree.addNode(7);
        binaryTree.addNode(8);
        System.out.println(binaryTree.preFindNode(50));
    }

    static class MyBinaryTree {

        private Node node;

        // 添加二叉树节点
        public void addNode(Integer data) {
            if (null == node) {
                node = new Node(data);
            } else {
                addNode(data, node);
            }
        }

        private void addNode(Integer data, Node node) {
            if (null == node) {
                throw new RuntimeException("Node 节点为空");
            }
            if (data > node.getData()) {
                Node rightNode = node.getRightNode();
                if (null == rightNode) {
                    Node newNode = new Node(data);
                    node.setRightNode(newNode);
                    newNode.setParentNode(node);
                } else {
                    addNode(data, node.getRightNode());
                }
            } else if (data < node.getData()) {
                Node leftNode = node.getLeftNode();
                if (null == leftNode) {
                    Node newNode = new Node(data);
                    node.setLeftNode(newNode);
                    newNode.setParentNode(node);
                } else {
                    addNode(data, node.getLeftNode());
                }
            } else {
                System.out.println("数据节点已经存在");
            }
        }

        // 前序查找
        public Integer preFindNode(Integer targetData) {
            return doPreFindNode(targetData, node);
        }

        public Integer doPreFindNode(Integer targetData, Node node) {
            if (null == node) {
                return null;
            }
            if (targetData == node.getData()) {
                return node.getData();
            } else if (targetData < node.getData()) {
                return doPreFindNode(targetData, node.getLeftNode());
            } else if (targetData > node.getData()) {
                return doPreFindNode(targetData, node.getRightNode());
            }
            return null;
        }

        // 中序查找
        public Integer middleFindNode(Integer targetData) {
            return doMiddleFindNode(targetData, node);
        }

        public Integer doMiddleFindNode(Integer targetData, Node node) {
            if (null == node) {
                return null;
            }
            if (targetData < node.getData()) {
                return doMiddleFindNode(targetData, node.getLeftNode());
            } else if (targetData == node.getData()) {
                return node.getData();
            } else if (targetData > node.getData()) {
                return doMiddleFindNode(targetData, node.getRightNode());
            }
            return null;
        }

        // 后序查找
        public Integer postFindNode(Integer targetData) {
            return doPostFindNode(targetData, node);
        }

        public Integer doPostFindNode(Integer targetData, Node node) {
            if (null == node) {
                return null;
            }
            if (targetData < node.getData()) {
                return doPostFindNode(targetData, node.getLeftNode());
            } else if (targetData > node.getData()) {
                return doPostFindNode(targetData, node.getRightNode());
            } else if (targetData == node.getData()) {
                return node.getData();
            }
            return null;
        }

    @Data
    @ToString
    static class Node {

        private Integer data;

        private Node leftNode;

        private Node rightNode;

		private Node parentNode;

        public Node() {}

        public Node(Integer data) {
            this(data, null, null);
        }

        public Node(Integer data, Node leftNode, Node rightNode) {
            this.data = data;
            this.leftNode = leftNode;
            this.rightNode = rightNode;
        }

    }
}

4，二叉树删除

4.1，删除步骤

  • 如果删除的节点是叶子节点，则直接删除
  • 如果删除的是非叶子节点，则需要对删除节点的子节点进行处理
  • 用右侧最左节点代替该节点，并删除右侧最左节点

4.2，删除代码实现

package com.self.datastructure.tree;

import lombok.Data;
import lombok.ToString;

import java.util.ArrayList;
import java.util.List;

/**
 * 二叉树
 *
 * @author pj_zhang
 * @create 2020-03-21 22:02
 **/
public class BinaryTree {

    public static void main(String[] args) {
        MyBinaryTree binaryTree = new MyBinaryTree();
        binaryTree.addNode(5);
        binaryTree.addNode(2);
        binaryTree.addNode(1);
        binaryTree.addNode(4);
        binaryTree.addNode(3);
        binaryTree.addNode(8);
        binaryTree.addNode(6);
        binaryTree.addNode(9);
        binaryTree.addNode(10);
        binaryTree.middleShowDetails();
        System.out.println(binaryTree.delNode(1));;
        binaryTree.middleShowDetails();
    }

    static class MyBinaryTree {

        private Node node;

        // 添加二叉树节点
        public void addNode(Integer data) {
            if (null == node) {
                node = new Node(data);
            } else {
                addNode(data, node);
            }
        }

        private void addNode(Integer data, Node node) {
            if (null == node) {
                throw new RuntimeException("Node 节点为空");
            }
            if (data > node.getData()) {
                Node rightNode = node.getRightNode();
                if (null == rightNode) {
                    node.setRightNode(new Node(data));
                } else {
                    addNode(data, node.getRightNode());
                }
            } else if (data < node.getData()) {
                Node leftNode = node.getLeftNode();
                if (null == leftNode) {
                    node.setLeftNode(new Node(data));
                } else {
                    addNode(data, node.getLeftNode());
                }
            } else {
                System.out.println("数据节点已经存在");
            }
        }

        /**
         * 二叉树节点删除
         * * 如果删除节点为叶子节点, 则直接删除
         * * 如果删除节点为非叶子节点, 且只有左节点或者有节点其中一个节点, 将子节点设置为该节点
         * * 如果删除节点为非叶子节点, 则子节点完整, 则让右子节点代替该节点, 左子节点按顺序挂在右子节点的左侧位置
         *
         * @param targetData
         * @return
         */
        public boolean delNode(Integer targetData) {
            if (null == node) {
                return false;
            }
            return doDelNode(targetData, node);
        }

        private boolean doDelNode(Integer targetData, Node node) {
            if (null == node) {
                return false;
            }
            if (targetData > node.getData()) {
                // 删除值大于当前节点值, 向右查找
                return doDelNode(targetData, node.getRightNode());
            } else if (targetData < node.getData()) {
                // 删除值小于当前节点值, 向左查找
                return doDelNode(targetData, node.getLeftNode());
            } else {
                // 找到后, 进行处理
                // 获取右侧节点的最左节点
                Node nextNode = findNextNode(node);
                // 说明存在右侧节点
                if (null == nextNode) {
                    // 直接用左侧节点替换该节点
                    // 如果当前节点是根节点, 直接将根节点替换为其左侧节点
                    if (this.node == node) {
                        this.node = node.getLeftNode();
                        this.node.setParentNode(null);
                    } else {
                        // 删除节点是中间节点, 如果是父节点的左侧节点, 则将父节点的左侧节点替换为其左侧节点
                        if (node == node.getParentNode().getLeftNode()) {
                            node.getParentNode().setLeftNode(node.getLeftNode());
                        } else if (node == node.getParentNode().getRightNode()) {
                            // 删除节点是中间节点, 如果是父节点的右侧节点, 则将父节点的右侧节点替换为其左侧节点
                            node.getParentNode().setRightNode(node.getLeftNode());
                        }
                        if (null != node.getLeftNode()) {
                            node.getLeftNode().setParentNode(node.getParentNode());
                        }
                    }
                } else {
                    // 存在后继节点
                    // 将当前值替换为后继节点的值
                    node.setData(nextNode.getData());
                    // 将后继节点挂空, 后继节点可能存在右侧节点, 用右侧节点进行替换
                    if (nextNode == nextNode.getParentNode().getLeftNode()) {
                        nextNode.getParentNode().setLeftNode(nextNode.getRightNode());
                    } else if (nextNode == nextNode.getParentNode().getRightNode()) {
                        // 删除节点是中间节点, 如果是父节点的右侧节点, 则将父节点的右侧节点替换为其左侧节点
                        nextNode.getParentNode().setRightNode(nextNode.getRightNode());
                    }
                    if (null != nextNode.getRightNode()) {
                        nextNode.getRightNode().setParentNode(nextNode.getParentNode());
                    }
                }
                return true;
            }
        }

        /**
         * 获取右侧节点的最左节点
         * @param node
         * @return
         */
        private Node findNextNode(Node node) {
            Node nextNode = node.getRightNode();
            if (null == nextNode) {
                return nextNode;
            }
            while (null != nextNode.getLeftNode()) {
                nextNode = nextNode.getLeftNode();
            }
            return nextNode;
        }

        // 中序输出
        // 先输出左侧节点值
        // 再输出当前节点值
        // 最后输出中间节点值
        // 中序输出结果为有序数组
        public void middleShowDetails() {
            doMiddleShowDetails(node);
        }

        public void doMiddleShowDetails(Node node) {
            if (null == node) {
                return;
            }
            if (null != node.getLeftNode()) {
                doMiddleShowDetails(node.getLeftNode());
            }
            System.out.println("Node: " + node.getData());
            if (null != node.getRightNode()) {
                doMiddleShowDetails(node.getRightNode());
            }
        }

    }

    @Data
    @ToString
    static class Node {

        private Integer data;

        private Node leftNode;

        private Node rightNode;

        public Node() {}

        public Node(Integer data) {
            this(data, null, null);
        }

        public Node(Integer data, Node leftNode, Node rightNode) {
            this.data = data;
            this.leftNode = leftNode;
            this.rightNode = rightNode;
        }

    }
}
传说中的靖哥哥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mysql左右值树_树形结构左右值存储，移动节点详解
weixin_33957458的博客
02-03 2065
最近做一个程序，用到树形结构，并且要存储到数据库中。于是研究了一下树形结构的左右值存储。左右值虽然取父祖节点和子孙节点，查找节点路径非常方便，但要找某节点的父节点，子节点和兄弟节点就比较困难，所以还要需要一个层级维度方便确定父子和兄弟节点，也就是树形结构中所说的树的深度。下面列举一些普通的左右值算法，网上有大量的资料，就不细说了。以下资料来自网上，错误的地方我已纠正一、计算某节点的子孙节点数。子孙...
排序算法：二叉排序树
aitazhixin的专栏
03-15 1246
利用二叉树排序树生成有序序列
二叉树基本知识
m0_50488845的博客
07-13 1007
二叉树
二叉树：二叉树的定义，性质及存储结构
weixin_65244004的博客
08-26 2018
二叉树：二叉树的定义，性质及存储结构
二叉排序树
loserbai的博客
07-23 484
定义 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树； 特点 树的结构通常不是一次生成的，而是在查找过程中，当树中不存在 关键字 等于给定值的 结点 时再进行插入。 新插入的结点一定是一个新添加的 叶子结点 ，并且是查找不成功时查找路径上访问的最后一个结点的左孩子或右孩子结点。 首先执行查找算法，找出被插结点的父亲结点。 判断被插结点是其父亲.
【树】二叉树
dodobibibi的博客
02-19 146
数的概念 树(英语：tree)是一种抽象数据类型(ADT)或是视作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n(n>=1)个有限节点组成一个具有层次关系的集合，把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个节点有零个或多个子节点树的术语 没有父节点的节点称为根节点 每一个非根节点有且只有一个父节点 除了根节点...
二叉树，二叉排序树
byronone的专栏
03-24 1523
一、二叉树的顺序存储表示     利用满二叉树的特性，在线性表中存储数节点；因此可以利用节点的编号（从左到右，按层标记，根节点标记为0）作为数组的下标，且父节点（p）和子节点（c）下标存在如下关系：p=(c-1)/2；c1=2*p+1；c2=2*p+2。     缺点：如果数是一棵稀疏的树，那么会浪费大量存储空间。二、二叉树的链表存储表示     三叉链表结构中每个树节点有一个指向父节点的指针，有...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右子树非空，则右子树上所有结点的值均大于根结点的值；3.左、右子树本身又各...
数据结构实验：二叉排序树的插入和删除算法
最新发布
10-17
为了向二叉排序树中插入一个新元素，必须先检查这个元素在二叉排序树中是否已经存在。因此，在插入之前，首先在二叉排序树中检查待插入的数据元素，如果查找成功，说明树中已经存在这个数据元素，则不再插入:如果...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键性质： 1. 左子树上的所有节点的值都小于当前节点的值。 2. 右子树上的所有节点的值都大于当前...
左右侧的树选择节点功能
01-05
从左侧的树选择节点，右侧将选择的节点按照树形显示。 如果父节点选择，则子节点默认全部选中，所以在右侧默认不显示子节点 写的比较仓促，左边的树是在微软的基础上改进的，右边的树是我以前写的一个根据xml+xsl生成树的小程序 选择移除操作都是对xmldom进行操作，操作完了重新加载这个xmldom
Java实现二叉排序树
09-02
二叉排序树（Binary Sort Tree，BST），也称为二叉搜索树，是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子节点的指针和一个指向右子节点的指针。在二叉排序树中，对于...
C/C++:二叉排序树.rar(含完整注释)
03-04
设二叉排序树的二叉链表存储结构的类型定义如下： typedef struct node{ int data; //用整数表示一个结点的名 struct node *LChild,*RChild; //左右指针域 }BSTNode,*BSTree; 设计算法并编写程序求解以下几个问题...
二叉排序树详解以及实现
Keep_Trying_Go的博客
01-02 2920
二叉排序树详解以及实现
数据结构之二叉排序树
y_k_j_c的博客
11-01 194
主要是左子树的节点上的值全都小于右子树。
堆是也可以看成一种树结构,规定根节点必须大于或小于左右子节点,但左右子节点的大小顺序没有规定
weixin_47303191的博客
06-06 698
堆不算是一种数据结构,只是一类数据结构的统称,通常用完全二叉树来实现堆.完全二叉树即除了叶子节点外,必须存在左右孩子节点的树.不完全二叉树是除了叶子节点外,存在一个或多个节不完全存在左右孩子节点.在前面小编提到过一笔,树不一定要用向链表那样的结构去实现的,我们完全可以用数组,用数组的好处是,可以快速遍历,根据某个节点,我们可以快速获取其父节点或者子节点,请看下图数组存储树的结构:如果一个节点的位置是k,那么其父节点的位置是k/2,其左子节点为k/2,右子节点为k/2+1.其次,树的根节点一定要大于左右子节点
数据结构二叉树的基本概念
qq_45841224的博客
01-02 551
树的优点：以有序二叉树来说 可以提高检索效率（二分查找）同时也可以提高数据的存储检索效率，但是删除 会相对麻烦一点。 树的元素：结点、高度、层（这是结点的属性）、根节点、父节点、子节点、叶子结点（没有子节点） 根节点：树的最上面第一层的结点；父节点：每一个结点最多只有一个父节点 根节点没有父节点 子结点：每个结点最多有两个左右子结点（这是二叉树）、叶子结点没有子结点，叶子结点的最大层数就是 树的高度 ，也就是最下面的结点在第几层。 路径：从根结点到某一结点的路径 树有很多种我们最常见的就是二叉树：
数据结构——堆
weixin_57023347的博客
06-21 576
文章目录前言一.定义三.重要操作1.向下调整堆2.建立堆3.插入向上调整堆4.删除四.代码实现堆 前言 在现实生活中，我们处理事情时大多数情况下，我们并不是按照顺序，先来先处理的。许多情况下，我们会按照事情优先级来处理事情。比如：某个外科医生，某个患者受了点皮外伤，而排在他后面的患者受了很严重的外伤，这个医生肯定优先处理那个受了严重外伤的患者。下面介绍的堆正是考虑了这种特性的数据结构，通常堆也被称为“优先队列”。 一.定义 堆是一种特殊的队列，从堆中取出来的元素是按照元素优先级的大小，而不是元素进入队
普里姆（Prim）算法（P算法）：修路问题
zp_zhang的博客
07-18 2727
1，应用场景—修路问题 如图，此时有7个村庄['A', 'B', 'C', 'D', 'E', 'F', 'G']，现在需要把这7个村庄连通 村庄之间的连接线表示可能修路的图示，权值表示举例 此时，如果想要把7个村庄连通，怎么才能让连接的路程最短？ 此时应该尽可能的寻找少的线路，保证每条线路最短，最终达到整体线路最短（该部分有点类似贪心，但是贪心的最终结果不一定是最优解） 2，最小生成树问题 修路问题本身就是最小生成树（Minimum Cost Spanning Tree）问题，简称MST：给定一个

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值