平衡树代码总结

最新推荐文章于 2022-04-22 20:57:01 发布
最新推荐文章于 2022-04-22 20:57:01 发布
阅读量115 收藏
点赞数
原文链接：http://www.cnblogs.com/Robin20050901/p/10665195.html
版权

这里给出博主的几种平衡树模板代码

vector

代码：

// luogu-judger-enable-o2
#include<bits/stdc++.h>

#define rd(x) x=read()

using namespace std;

int n;
vector<int>v;

inline int read()
{
    int f=1,x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}

int main()
{
    rd(n);
    for(int i=1;i<=n;i++)
    {
        int opt,x;
        rd(opt),rd(x);
        if(opt==1)v.insert(upper_bound(v.begin(),v.end(),x),x);
        else if(opt==2)v.erase(lower_bound(v.begin(),v.end(),x));
        else if(opt==3)printf("%d\n",lower_bound(v.begin(),v.end(),x)-v.begin()+1);
        else if(opt==4)printf("%d\n",v[x-1]);
        else if(opt==5)printf("%d\n",*--lower_bound(v.begin(),v.end(),x));
        else if(opt==6)printf("%d\n",*upper_bound(v.begin(),v.end(),x));
    }
    return 0;
}
Treap:
// luogu-judger-enable-o2
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<bits/stdc++.h>

#define rd(x) x=read()
#define N 100005
#define inf (1<<30) 

using namespace std;

inline int read()
{
    int f=1,x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}

int q;
int ncnt,root;
struct T{
    int s,v,cnt,rnd,ch[2];
}t[N];

void pushup(int rt){t[rt].s=t[t[rt].ch[0]].s+t[t[rt].ch[1]].s+t[rt].cnt;}

void rotate(int &rt,int d)
{
    int k=t[rt].ch[d^1];
    t[rt].ch[d^1]=t[k].ch[d];
    t[k].ch[d]=rt;
    pushup(rt),pushup(k);
    rt=k;
}

void ins(int &rt,int x)
{
    if(!rt)
    {
        rt=++ncnt,t[rt].s=t[rt].cnt=1,t[rt].v=x,t[rt].rnd=rand();
        return ;
    }
    if(t[rt].v==x){t[rt].cnt++,t[rt].s++;return ;}
    int d=(x>t[rt].v);
    ins(t[rt].ch[d],x);
    if(t[rt].rnd<t[t[rt].ch[d]].rnd)rotate(rt,d^1);
    pushup(rt);
}

void del(int &rt,int x)
{
    if(!rt)return;
    if(x<t[rt].v)del(t[rt].ch[0],x);
    else if(x>t[rt].v)del(t[rt].ch[1],x);
    else
        if(t[rt].ch[0])
            if(t[rt].ch[1])
            {
                int d=(t[t[rt].ch[0]].rnd>t[t[rt].ch[1]].rnd);
                rotate(rt,d);
                del(t[rt].ch[d],x);
            }
            else
            {
                rotate(rt,1);
                del(t[rt].ch[1],x);
            }
        else
            if(t[rt].ch[1])
            {
                rotate(rt,0);
                del(t[rt].ch[0],x);
            }
            else
            {
                t[rt].cnt--,t[rt].s--;
                if(!t[rt].cnt)rt=0;
            }
    pushup(rt);
}

int rank(int rt,int x)
{
    if(!rt)return 0;
    if(t[rt].v==x)return t[t[rt].ch[0]].s+1;
    else if(t[rt].v<x)return t[t[rt].ch[0]].s+t[rt].cnt+rank(t[rt].ch[1],x);
    else return rank(t[rt].ch[0],x);
}

int find(int rt,int x)
{
    if(!rt)return 0;
    if(t[t[rt].ch[0]].s>=x)return find(t[rt].ch[0],x);
    else if(t[t[rt].ch[0]].s+t[rt].cnt<x)return find(t[rt].ch[1],x-t[rt].cnt-t[t[rt].ch[0]].s);
    else return t[rt].v;
}

int pre(int rt,int x)
{
    if(!rt)return -inf;
    if(t[rt].v>=x)return pre(t[rt].ch[0],x);
    else return max(t[rt].v,pre(t[rt].ch[1],x));
}

int suc(int rt,int x)
{
    if(!rt)return inf;
    if(t[rt].v<=x)return suc(t[rt].ch[1],x);
    else return min(t[rt].v,suc(t[rt].ch[0],x));
}

int main()
{
    rd(q);
    while(q--)
    {
        int opt,x;
        rd(opt),rd(x);
        if(opt==1)ins(root,x);
        else if(opt==2)del(root,x);
        else if(opt==3)printf("%d\n",rank(root,x));
        else if(opt==4)printf("%d\n",find(root,x));
        else if(opt==5)printf("%d\n",pre(root,x));
        else printf("%d\n",suc(root,x));
    }
    
    return 0;
}
Splay
// luogu-judger-enable-o2
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<iostream>
#include<cstdio>

#define rd(x) x=read()
#define N 100005

using namespace std;

int q;
int ncnt,root;
struct T{
    int s,v,cnt,fa,ch[2];
}t[N];

inline int read()
{
    int f=1,x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}

int chk(int rt){return t[t[rt].fa].ch[1]==rt;}

int pushup(int rt){return t[rt].s=t[t[rt].ch[0]].s+t[t[rt].ch[1]].s+t[rt].cnt;}

void rotate(int x)
{
    int y=t[x].fa,z=t[y].fa,k=chk(x),w=t[x].ch[k^1];
    t[y].ch[k]=w,t[w].fa=y;
    t[z].ch[chk(y)]=x,t[x].fa=z;
    t[x].ch[k^1]=y,t[y].fa=x;
    pushup(y),pushup(x);
}

void splay(int x,int goal=0)
{
    while(t[x].fa!=goal)
    {
        int y=t[x].fa,z=t[y].fa;
        if(z!=goal)
        {
            if(chk(x)==chk(y))rotate(y);
            else rotate(x);
        }
        rotate(x);
    }
    if(!goal)root=x;
}

void ins(int x)
{
    int rt=root,pos=0;
    while(rt&&t[rt].v!=x)pos=rt,rt=t[rt].ch[x>t[rt].v];
    if(rt)t[rt].cnt++;
    else
    {
        rt=++ncnt; 
        if(pos)t[pos].ch[x>t[pos].v]=rt;
        t[rt].ch[0]=t[rt].ch[1]=0;
        t[rt].fa=pos,t[rt].v=x;
        t[rt].cnt=t[rt].s=1;
    }
    splay(rt);
}

void find(int x)
{
    int rt=root;
    while(t[rt].ch[x>t[rt].v]&&t[rt].v!=x)rt=t[rt].ch[x>t[rt].v];
    splay(rt);
}

int rank(int k)
{
    int rt=root;
    while("zth loves msy")
    {
        if(t[rt].ch[0]&&k<=t[t[rt].ch[0]].s)rt=t[rt].ch[0];
        else if(k>t[t[rt].ch[0]].s+t[rt].cnt)k-=t[t[rt].ch[0]].s+t[rt].cnt,rt=t[rt].ch[1];
        else return rt;	 
    }
}

int pre(int x)
{
    find(x);
    if(t[root].v<x)return root;
    int rt=t[root].ch[0];
    while(t[rt].ch[1])rt=t[rt].ch[1];
    return rt;
}

int suc(int x)
{
    find(x);
    if(t[root].v>x)return root;
    int rt=t[root].ch[1];
    while(t[rt].ch[0])rt=t[rt].ch[0];
    return rt;
}

void del(int x)
{
    int last=pre(x),next=suc(x);
    splay(last),splay(next,last);
    int _del=t[next].ch[0];
    if(t[_del].cnt>1)
    {
        t[_del].cnt--;
        splay(_del);
    }
    else t[next].ch[0]=0;
} 

int main()
{
    rd(q);
    ins(0x3f3f3f3f),ins(0xcfcfcfcf);
    while(q--)
    {
        int opt,x;
        rd(opt),rd(x);
        if(opt==1)ins(x);
        else if(opt==2)del(x);
        else if(opt==3){find(x);printf("%d\n",t[t[root].ch[0]].s);}
        else if(opt==4)printf("%d\n",t[rank(x+1)].v);
        else if(opt==5)printf("%d\n",t[pre(x)].v);
        else printf("%d\n",t[suc(x)].v);
    }
    
    return 0;
}
替罪羊树
// luogu-judger-enable-o2
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<bits/stdc++.h>

#define rd(x) x=read()
#define N 100005

using namespace std;

struct T{
    int s,f,v,d,ch[2];
}t[N];
int ncnt,root,cnt;
int Lrd[N],r[N];
int n;
const double p=0.75;


inline int read()
{
    int f=1,x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}

void init(int rt)
{
    t[rt].s=t[rt].f=1;
    t[rt].ch[0]=t[rt].ch[1]=0;
}

bool bal(int rt){return (double)t[rt].f*p>(double)max(t[t[rt].ch[0]].f,t[t[rt].ch[1]].f);} 

void lrd(int rt)
{
    if(!rt)return;
    lrd(t[rt].ch[0]);
    if(t[rt].d)Lrd[++cnt]=rt;
    lrd(t[rt].ch[1]);
}

void pushup(int rt)
{
    t[rt].s=t[t[rt].ch[0]].s+t[t[rt].ch[1]].s+1; 
    t[rt].f=t[t[rt].ch[0]].f+t[t[rt].ch[1]].f+1;
}

void setup(int &rt,int l,int r)
{
    int mid=(l+r)>>1;
    rt=Lrd[mid];
    if(l==r){init(rt);return;}
    if(l<mid)setup(t[rt].ch[0],l,mid-1);
    else t[rt].ch[0]=0;
    setup(t[rt].ch[1],mid+1,r);
    pushup(rt);
}

void rebuild(int &rt)
{
    cnt=0;
    lrd(rt);
    if(cnt)setup(rt,1,cnt);
    else rt=0;
}

void check(int rt,int v)
{
    int k=(v>t[rt].v);
    while(t[rt].ch[k])
    {
        if(!bal(t[rt].ch[k]))
        {
            rebuild(t[rt].ch[k]);
            return ;
        }
        rt=t[rt].ch[k];
        k=(v>t[rt].v);
    }
}

void ins(int &rt,int x)
{
    if(!rt)
    {
        rt=++ncnt,t[rt].v=x,t[rt].d=1,init(rt);
        return ;
    }
    t[rt].s++,t[rt].f++;
    if(x<=t[rt].v)ins(t[rt].ch[0],x);
    else ins(t[rt].ch[1],x);
}

int rank(int x)
{
    int rk=1,rt=root;
    while(rt) 
    {
        if(t[rt].v>=x)rt=t[rt].ch[0];
        else rk+=t[t[rt].ch[0]].f+t[rt].d,rt=t[rt].ch[1];
    }
    return rk;
}

int find(int x)
{
    int rt=root;
    while(rt)
    {
        if(t[rt].d&&t[t[rt].ch[0]].f+1==x)return t[rt].v;
        else if(t[t[rt].ch[0]].f>=x)rt=t[rt].ch[0];
        else x-=t[rt].d+t[t[rt].ch[0]].f,rt=t[rt].ch[1];
    }
}

void del(int &rt,int rk)
{
    if(t[rt].d&&t[t[rt].ch[0]].f+1==rk)
    {
        t[rt].d=0;
        t[rt].f--;
        return ;
    }
    t[rt].f--;
    if(t[t[rt].ch[0]].f+t[rt].d>=rk)del(t[rt].ch[0],rk);
    else del(t[rt].ch[1],rk-t[rt].d-t[t[rt].ch[0]].f);
}

void Del(int x)
{
    del(root,rank(x));
    if((double)t[root].s*p>(double)t[root].f)rebuild(root);
}
 
int main()
{
    rd(n);
    while(n--)
    {
        int opt,x;
        rd(opt),rd(x);
        if(opt==1)ins(root,x),check(root,x);
        else if(opt==2)Del(x);
        else if(opt==3)printf("%d\n",rank(x));
        else if(opt==4)printf("%d\n",find(x));
        else if(opt==5)printf("%d\n",find(rank(x)-1));
        else printf("%d\n",find(rank(x+1)));
    }
    
    return 0;
}
FHQ treap
// luogu-judger-enable-o2
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#include<bits/stdc++.h>

#define rd(x) x=read()
#define N 100005

using namespace std;

int n;
int ncnt;
struct T{
    int v,rnd,s,ch[2];
}t[N];

inline int read()
{
    int f=1,x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}

void update(int rt){t[rt].s=t[t[rt].ch[0]].s+t[t[rt].ch[1]].s+1;}

int NewNode(int v)
{
    t[++ncnt].s=1;
    t[ncnt].v=v;
    t[ncnt].rnd=rand();
    return ncnt;
}

int merge(int x,int y)
{
    if(!x||!y) return x+y;
    if(t[x].rnd<t[y].rnd)
    {
        t[x].ch[1]=merge(t[x].ch[1],y);
        update(x);
        return x;
    }
    else
    {
        t[y].ch[0]=merge(x,t[y].ch[0]);
        update(y);
        return y;
    }
}

void split(int rt,int pos,int &l,int &r)
{
    if(!rt)l=r=0;
    else
    {
        if(t[rt].v<=pos)
        {
            l=rt;
            split(t[rt].ch[1],pos,t[rt].ch[1],r);
        }
        else
        {
            r=rt;
            split(t[rt].ch[0],pos,l,t[rt].ch[0]);
        }
        update(rt);
    }
}

int kth(int rt,int pos)
{
    while(1)
    {
        if(pos<=t[t[rt].ch[0]].s)rt=t[rt].ch[0];
        else if(pos==t[t[rt].ch[0]].s+1) return rt;
        else
        {
            pos-=t[t[rt].ch[0]].s+1;
            rt=t[rt].ch[1];
        }
    }
}

int main()
{
    srand(time(0));
    rd(n);
    int root=0,x,y,z;
    while(n--)
    {
        int opt,a;
        rd(opt),rd(a);
        if(opt==1)
        {
            split(root,a,x,y);
            root=merge(merge(x,NewNode(a)),y);
        }
        else if(opt==2) 
        {
            split(root,a,x,z);
            split(x,a-1,x,y);
            y=merge(t[y].ch[0],t[y].ch[1]);
            root=merge(merge(x,y),z);
        }
        else if(opt==3)
        {
            split(root,a-1,x,y);
            printf("%d\n",t[x].s+1);
            root=merge(x,y);
        }
        else if(opt==4)printf("%d\n",t[kth(root,a)].v);
        else if(opt==5) 
        {
            split(root,a-1,x,y);
            printf("%d\n",t[kth(x,t[x].s)].v);
            root=merge(x,y);
        }
        else if(opt==6)
        {
            split(root,a,x,y);
            printf("%d\n",t[kth(y,1)].v);
            root=merge(x,y);
        }
    }
    
    return 0;
}

转载于:https://www.cnblogs.com/Robin20050901/p/10665195.html

weixin_30408675
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
平衡二叉树源代码
01-31
平衡二叉树源代码
平衡二叉树（AVL树）
qq_43906881的博客
10-20 180
平衡二叉树（AVL树） 1、问题引入 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在. 左子树全部为空，从形式上看，更像一个单链表. 插入速度没有影响 查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢 解决方案-平衡二叉树(AVL) 2、基本介绍 平衡二叉树也叫平衡 二叉搜索树（Self-balancingbinary search tree）又被称为 AVL 树，可以保证查询效率较高。 具有以
平衡树的代码实现
空梦的博客
04-22 471
使用C++以及Kotlin编写弱平衡树的实现。 注意：这里实现的弱平衡树不是任何网上的弱平衡树（比如：红黑树、Splay等），是我完全按照前面的理论写的。 原帖：https://kmar.top/posts/af2cae0b/
ｃ语言平衡树代码
ajdjirkdnkfk的博客
11-19 459
ｃ语言平衡树代码 avl_tree.h #ifndef _AVL_TREE #define _AVL_TREE #include <stdio.h> #include <string.h> #include <unistd.h> #include <stdlib.h> #include <math.h> #include "queue.h" #define LH 1 #define RH -1 #define EH 0 typedef struc
编程练习——平衡树（AVLTree）
帐前卒 专栏
08-19 1039
AVLTree本身就是二叉查找树。为了保证查找效率在O(nlogn),所以有时要对树高进行必要的调整。AVLTree拥有自己的法则使得插入、删除、查找都在O(nlogn)时间内完成。下面写了一个AVLTreeNode类，好像和TreeNode类一样。 下面写AVLTree类，这个类重要的地方在与插入和删除操作。查找操作和BinarySearchTree一致。但是至今还没有找到一个有
二叉排序树与平衡二叉树的实现
12-26
二叉平衡树：若不是空树，则(1)左右子树都是平衡二叉树；(2)左右子树的深度之差的绝对值不超过1。 本次实验是利用二叉排序树和平衡二叉树达到以下目的：(1)以回车('\n')为输入结束标志,输入数列L，生成一棵二叉...
c++嵌入式软件面试总结
07-08
"c++嵌入式软件面试总结...B树是一种自平衡搜索树，用于索引查询。B树的每个节点的元素可以视为一次I/O读取，树的高度表示最多的I/O次数。在相同数量的总元素个数下，每个节点的元素个数越多，高度越低，查询速度越快。
数据结构总结（自学、期末复习或考研备用）.pdf
01-16
折半查找、插值查找、次优二叉树、二叉排序树(BST)、二叉平衡树(AVL树)、左旋和右旋 平衡二叉树的插入:、哈希表、Hash碰撞的解决方案?、链地址法、开放地址法、第九章排序、直接插入排序、折半插入排序、表插入排序...
ACM比赛经验与常见问题对应的解题技巧总结
最新发布
03-26
数据结构方面，不仅要掌握数组、链表、栈、队列、哈希表、集合、树（二叉树、平衡树、红黑树、B树等）的基本操作，还要了解其在不同问题中的应用场景。 刷题训练的实例： 在LeetCode等平台上，针对特定类型题目进行...
《Delphi 深度编程及其项目应用开发》PDF书及代码
01-13
16.1 通用查询组件的创建 16.2 通用报表模块的制作 第17章 通用基础数据维护模块的设计 17.1 界面设计 17.2 代码实现 17.2.1 以目录树的格式显示部门档案数据 17.2.2 利用目录树导航数据 17.2.3 利用目录树操作数据 ...
平衡二叉树完整代码（创建，插入，旋转）
07-20
该套代码是博主在学习数据结构的平衡二叉树时总结整理的一套平衡二叉树的代码，包括平衡二叉树的创建，插入，旋转，遍历等一套完善的代码，亲自测试过，代码保证是对的。
平衡二叉查找树算法代码
12-17
平衡二叉查找树代码 AVL 二叉树 查找树
平衡树AVLTree的代码
03-13 285
也是以前写的程序,是实现平衡树的,现在都有点看不懂了,拿出来晒晒.AVL算法参考:http://www.nocow.cn/index.php/AVL%E6%A0%91-----------------------------------------------------------------------------------------describe.h是用来描述返回值的(当初居然用con
平衡二叉树代码实现
明月如霜，照见人如画
06-11 280
平衡二叉树（AVL树）的详细介绍：https://blog.csdn.net/qq_43643944/article/details/116354568 #include <iostream> using namespace std; typedef struct BiTNode { //结点定义 int data; int height;//高度，表示以当前结点为根的子树的高度 struct BiTNode *lchild, *rchild; } BiTNode,.
16-1平衡树源代码
weixin_30794499的博客
03-05 115
本例子分为3个文件。 类声明头文件 hAVL.h #ifndef AVLTREE_H_INCLUDED #define AVLTREE_H_INCLUDED //AVL树数据结构定义 typedef int ElementType;//AVL数节点包含数据类型 //树节点 typedef struct AVLNode{ ElementType element;...
【数据结构—查找】高度平衡树（AVL树）（含代码实现）
青山的青衫的博客
04-02 1027
文章目录高度平衡树（AVL树）1.定义AVL结点定义2.AVL的插入失衡情况平衡方案1.单旋转（LL\RR）LL型（右旋转）RR型（左旋转）2.双旋转—旋转两次（LR\RL）LR型（以C为轴先左转后右转）RL型（以C为轴先右转后左转）AVL插入的总结3.AVL树的删除（代码未实现） 高度平衡树（AVL树） 1.定义 关于二叉查找树~ 高度平衡树结点q的平衡系数为q的右子树高度减去左子树高度。 另：树的高度是指树中结点的最大层数（似乎不同教材对于从0开始还是从1开始的定义不同） 高度平衡树所有结点的平衡
编程--平衡二叉树
snowyuuu的博客
08-13 460
平衡二叉树，是一种二叉排序树，其中每个结点的左子树和右子树的高度差至多等于1。它是一种高度平衡的二叉排序树。高度平衡？意思是说，要么它是一棵空树，要么它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。 实现代码： class Solution { public: //求树的深度 int GetHeightR(TreeNode *pRoot){ ...
平衡二叉树（AVL 树）：概念、实现原理和算法代码
16A086的博客
06-18 883
文章目录引入定义实现原理概述单旋转双旋转实现算法单旋转双旋转插入操作参考资料 引入 上一篇中已经介绍了二叉搜索树（BST），在二叉搜索树的复杂度分析中，我们提到，二叉搜索树的算法复杂度与其拓扑结构（具体来说是其树的深度）有关。当 BST 最为「平衡」时，查找、删除、插入的算法为 O(log⁡n)O(\log{n})O(logn)，而最不平衡情况下，算法复杂度为 O(n)O(n)O(n)。 当节点数 nnn 增长时，O(log⁡n)O(\log{n})O(logn) 的算法相对于 O(n)O(n)O(n) 的
平衡二叉树（C++）(伪代码)
qq_42265608的博客
04-08 918
平衡二叉树： 查询复杂度为O（logn）； 左子树与右子树绝对值不超过1（平衡因子为左子树与右子树之差）； node* newNode(int v)//生成新节点，v为节点权值 { node *Node =new node;//申请node型的地址空间 Node->v=v; Node->height=1;//高度初始化为1； Node-&...
用C++写平衡树模板代码
03-26
上述代码给出了平衡树节点结构体、获取节点高度、获取节点平衡因子、更新节点高度、左旋、右旋、平衡操作、插入、查找、查找最小节点和删除等常用函数实现。同时，还给出了一个简单的测试代码，用于对平衡树进行测试...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值