数据结构中用C++实现平衡二叉搜索树

最新推荐文章于 2024-06-12 20:44:27 发布
最新推荐文章于 2024-06-12 20:44:27 发布
阅读量550 收藏
点赞数
分类专栏： 数据结构 算法导论 
#ifndef _AVL_H_
#define _AVL_H_
#include <iostream>
#define LH	1		//左高
#define EH	0		//等高
#define RH	-1		//右高
//平衡二叉排序树结点结构 
template <class ElemType,class KeyType>
struct AVLNode{
    ElemType data;					        //结点数据域
    AVLNode<ElemType,KeyType> *lchild;		//结点左孩子
    AVLNode<ElemType,KeyType> *rchild;		//结点右孩子
	int bf;							        //结点平衡因子
};
//平衡二叉排序树类
template< class ElemType,class KeyType>
class AVL{
public:
	AVL ();				
	~AVL ( );	
	bool Insert(const ElemType & e,const KeyType & key);//平衡二叉排序树中插入关键字为key的元素e
	bool Delete(const KeyType & key);//平衡二叉排序树中删除关键字为key的元素
	bool Search(const KeyType & key);//平衡二叉排序树中查找是否存在关键字为key的元素
	int GetDepth();	//求平衡二叉排序树的深度
	void InorderTraverse();	//中序遍历平衡二叉排序树
private:
	AVLNode<ElemType,KeyType> * m_T;//平衡二叉排序树根指针
	void _Destroy(AVLNode<ElemType,KeyType> * &T);//销毁平衡二叉排序树
	void _RRotate(AVLNode<ElemType,KeyType> * &T);//右旋操作
	void _LRotate(AVLNode<ElemType,KeyType> * &T);//左旋操作
	void _LeftBalance(AVLNode<ElemType,KeyType> * &T);//左平衡处理
	void _RightBalance(AVLNode<ElemType,KeyType> * &T);	//右平衡处理
	bool _Insert(AVLNode<ElemType,KeyType> * &T,ElemType e,KeyType key,bool &bTaller);//平衡二叉排序树中插入关键字为key的元素，并保持平衡状态
	bool _Delete(AVLNode<ElemType,KeyType> * &T,KeyType key,bool &bShorter);//平衡二叉排序树中删除关键字为Key的元素，并保持平衡状态
	AVLNode<ElemType,KeyType>* _Search(AVLNode<ElemType,KeyType>* T,KeyType key);//平衡二叉排序树中查找是否存在关键字key
	int  _GetDepth(AVLNode<ElemType,KeyType>* T);//求平衡二叉排序树的深度
	void _InorderTraverse(AVLNode<ElemType,KeyType>* T);//中序遍历二叉树
};
template< class ElemType,class KeyType>
AVL<ElemType,KeyType>::AVL ()
{
	m_T = NULL;
}
template< class ElemType,class KeyType>
AVL<ElemType,KeyType>::~AVL ( )
{
	_Destroy(m_T);
}
template< class ElemType,class KeyType>
bool AVL<ElemType,KeyType>::Insert(const ElemType & e,const KeyType & key)
{
	bool bTaller;
	return _Insert(m_T, e, key,bTaller);	
}
template< class ElemType,class KeyType>
bool AVL<ElemType,KeyType>::Delete(const KeyType & key)
{
	bool bShorter;
	return _Delete(m_T, key, bShorter);	
}
//在平衡二叉排序树中查找关键字为key的元素是否存在
template< class ElemType,class KeyType>
bool AVL<ElemType,KeyType>::Search(const KeyType & key)
{
	if (_Search(m_T,key) != NULL)
	return true;
	else return false;
}
// 初始条件: 平衡二叉排序树T存在。操作结果: 返回T的深度     
template <class ElemType,class KeyType> 
int AVL<ElemType,KeyType>::GetDepth()
{
    return _GetDepth(m_T);
}
// 中序遍历二叉树        
template <class ElemType,class KeyType>
void AVL <ElemType,KeyType>::InorderTraverse()
{
    _InorderTraverse(m_T);
} 
//销毁平衡二叉排序树
template< class ElemType,class KeyType>
void AVL<ElemType,KeyType>::_Destroy(AVLNode<ElemType,KeyType> * &T)
{
	 if(T){
        _Destroy(T->lchild);
        _Destroy(T->rchild);
        delete T;
        }
    T=NULL;  
}
//对以T为根的二叉排序树作右旋操作，操作后T指向新的树根结点
template< class ElemType,class KeyType>
void AVL<ElemType,KeyType>::_RRotate(AVLNode<ElemType,KeyType> * &T)
{
	AVLNode<ElemType,KeyType> * TempAVL;
	TempAVL = T->lchild;			//TempAVL指向T的左子树的根结点
	T->lchild = TempAVL->rchild;	//TempAVL的右子树挂接作为T的左子树
	TempAVL->rchild = T;			
	T = TempAVL;					//T指向新的树根结点
}
//对以T为根的二叉排序树作左旋操作。操作后T指向新的树根结点
template< class ElemType,class KeyType>
void AVL<ElemType,KeyType>::_LRotate(AVLNode<ElemType,KeyType> * &T)
{
	AVLNode<ElemType,KeyType> * TempAVL;
	TempAVL = T->rchild;			//TempAVL指向T的右子树的根结点
	T->rchild = TempAVL->lchild;	//TempAVL的左子树挂接作为T的右子树
	TempAVL->lchild = T;
	T = TempAVL;					//T指向新的树根结点
}
//对以T为根结点的二叉排序树作左平衡处理，处理完毕后T指向新的树根结点
template< class ElemType,class KeyType>
void AVL<ElemType,KeyType>::_LeftBalance(AVLNode<ElemType,KeyType> * &T)
{
	AVLNode<ElemType,KeyType> * tr, * TempAVL;
	tr = T->lchild;					//tr指向T的左子树的根结点
	switch(tr->bf){					//根据tr的平衡因子，作相应调整
	case LH:						//新结点插在T的左孩子的左子树上，作右旋操作
		T->bf = EH;
		_RRotate(T);
		tr->bf = EH;
		return;
	case RH:						//新结点插在T的左孩子的右子树上，作两次旋转操作
		TempAVL = tr->rchild;		//TempAVL指向tr的右子树的根结点上
		switch(TempAVL->bf){
		case LH:
			T->bf = RH;
			tr->bf = EH;
			break;
		case EH:
			T->bf = tr->bf = EH;
			break;
		case RH:
			T->bf = EH;
			tr->bf = LH;
			break;
		}
		TempAVL->bf = EH;
		_LRotate(T->lchild);		//对T的左子树作左旋操作
		_RRotate(T);				//对T作右旋操作
		return;
	}
	return;
}
//对以T为根结点的二叉排序树作右平衡处理，处理完毕后T指向新的树根结点
template< class ElemType,class KeyType>
void AVL<ElemType,KeyType>::_RightBalance(AVLNode<ElemType,KeyType> * &T)
{
	AVLNode<ElemType,KeyType> * tr, *TempAVL;
	tr = T->rchild;					//tr指向T的右子树的根结点
	switch(tr->bf){					//根据tr的平衡因子，作相应调整
	case RH:						//新结点插在T的右孩子的右子树上，作左旋操作
		T->bf = tr->bf = EH;
		_LRotate(T);
		return ;
	case LH:						//新结点插在T的右孩子的左子树上，作两次旋转操作
		TempAVL = tr->lchild;		//TempAVL指向tr的左子树的根结点上
		switch(TempAVL->bf){
		case RH:
			tr->bf = EH;
			T->bf = LH;
			break;
			
		case EH:
			T->bf = tr->bf = EH;
			break;
		case LH:
			tr->bf = RH;
			T->bf = EH;
			break;
		}
		TempAVL->bf = EH;
		_RRotate(T->rchild);		//对T的右子树作右旋操作
		_LRotate(T);				//对T作左旋操作
		return;
	}
	return ;
}
//若在平衡二叉排序树中不存在关键字为key的结点，则插入一个数据值为e的新结点，并返回true,否则返回false
//若插入过程中导致平衡二叉排序树失衡，则作相应调整，使之保持平衡状态，布尔值bTaller反映T是否长高。
template< class ElemType,class KeyType>
bool AVL<ElemType,KeyType>::_Insert(AVLNode<ElemType,KeyType> * &T,ElemType e,KeyType key,bool &bTaller)
{
	if(!T){									//若T为空树，则插入新结点作为根，bTaller为true
		T = new AVLNode<ElemType,KeyType>;
		T->lchild = T->rchild = NULL;
		T->bf = EH;
		T->data = e;
		bTaller = true;
		return true;
	}
	if(T->data == key)						//平衡二叉排序树中已存在和key相同关键字的结点，不再插入，返回false
		return false;
	if(T->data > key){						//在T的左子树中进行搜索
		if(!_Insert(T->lchild,e,key,bTaller))
			return false;
		if(bTaller){						//在T的左子树中插入新结点并使得左子树长高
			switch(T->bf){					//根据T的平衡因子作相应处理
			case LH:						//原本左子树高，则作左平衡处理
				_LeftBalance(T);
				bTaller = false;
				return true;
			case EH:						//原本等高，无需作平衡处理，整棵树长高
				bTaller = true;
				T->bf = LH;
				return true;
			case RH:						//原本右子树高，无需作平衡处理，整棵树未长高
				T->bf = EH;
				bTaller = false;
				return true;
			}
		}
	}else{									//在T的右子树中进行搜索
		if(!_Insert(T->rchild,e,key,bTaller))
			return false;
		if(bTaller){						//在T的右子树中插入新结点并使得右子树长高
			switch(T->bf){					//根据T的平衡因子作相应处理
			case LH:						//原本左子树高，无需作平衡处理，整棵树未长高
				T->bf = EH;
				bTaller = false;
				return true;
			case EH:						//原本等高，无需作平衡处理，整棵树长高
				T->bf = RH;
				bTaller = true;
				return true;
			case RH:						//原本右子树高，则作右平衡处理
				_RightBalance(T);
				bTaller = false;
				return true;
			}
		}
	}
	return true;
}
//若在平衡二叉排序树中存在和key有相同关键字的结点，则删除，并返回true,否则返回false
//若删除过程中导致平衡二叉排序树失衡，则作相应调整，使之保持平衡状态，布尔值bTaller反映T是否缩短。
template< class ElemType,class KeyType>
bool AVL<ElemType,KeyType>::_Delete(AVLNode<ElemType,KeyType> * &T,KeyType key,bool &bShorter)
{
	KeyType TempData;
	AVLNode<ElemType,KeyType> * tr;
	if(!T)											//T为空树，无法删除，返回false
		return false;
	if(T->data == key){								//找到数据值为key的结点T
		if(T->lchild == NULL && T->rchild == NULL){	//若T为叶子结点，删除
			delete T;
			T = NULL;
			bShorter = true;
			return true;
		}
		else if(T->lchild){							//若T无右子树
			tr = T->lchild;							//tr作为T的左子树的根结点
			while(tr->rchild)						//沿着tr的右子树分支一直找到最右端的结点
				tr = tr->rchild;
			TempData = T->data;
			T->data = tr->data;
			tr->data = TempData;
			if(!_Delete(T->lchild,key,bShorter))
				return false;
			if(bShorter){							//在T的左子树中删除结点	
				switch(T->bf){						//根据T的平衡因子作相应处理
				case LH:							//原本左子树高，则无需作平衡处理，树高缩短
					T->bf = EH;
					bShorter = true;
					return true;
				case EH:							//原本等高，则无需作平衡处理，树高未缩短	
					T->bf = RH;
					bShorter = false;
					return true;
				case RH:							//原本右高
					if(T->rchild->bf == EH)
						bShorter = false;
					else
						bShorter = true;
					_RightBalance(T);				//作右平衡处理	
					return true;
				}
			}
		}else if(T->rchild){						//若T无左子树
			tr = T->rchild;							//tr作为T的右子树的根结点
			while(tr->lchild)
				tr = tr->lchild;					//沿着tr的左子树分支一直找到最左端的结点
			TempData = T->data;
			T->data = tr->data;
			tr->data = TempData;
			if(!_Delete(T->rchild,key,bShorter))
				return false;
			if(bShorter){							//在T的右子树中删除结点
				switch(T->bf){						//根据T的平衡因子作相应处理
				case RH:							//原本右子树高，则无需作平衡处理，树高缩短
					bShorter = true;
					T->bf = EH;
					return true;
				case EH:							//原本等高，则无需作平衡处理，树高未缩短
					bShorter = false;
					T->bf = LH;
					return true;
				case LH:							//原本左高
					if(T->lchild->bf == EH)
						bShorter = false;
					else
						bShorter = true;
					_LeftBalance(T);				//作左平衡处理
					return true;
				}
			}
		}
	}else if(T->data > key){						//在T的左子树中搜索，若找到则删除
		if(!_Delete(T->lchild,key,bShorter))
			return false;
		if(bShorter){
			switch(T->bf){
			case LH:
				T->bf = EH;
				bShorter = true;
				return true;
			case EH:
				T->bf = RH;
				bShorter = false;
				return true;
			case RH:
				if(T->rchild->bf == EH)
					bShorter = false;
				else
					bShorter = true;
				_RightBalance(T);
				return true;
			}
		}
	}else{											//在T的右子树中搜索，若找到则删除
		if(!_Delete(T->rchild,key,bShorter))
			return false;
		if(bShorter){
			switch(T->bf){
			case RH:
				bShorter = true;
				T->bf = EH;
				return true;
			case EH:
				bShorter = false;
				T->bf = LH;
				return true;
			case LH:
				if(T->lchild->bf == EH)
					bShorter = false;
				else
					bShorter = true;
				_LeftBalance(T);
				return true;
			}
		}
	}
	return true;
}
//在以T为根的平衡二叉排序树中查找关键字为key的结点，若找到则返回该结点指针，否则返回NULL
template< class ElemType,class KeyType>
AVLNode<ElemType,KeyType> * AVL<ElemType,KeyType>::_Search(AVLNode<ElemType,KeyType> * T,KeyType key)
{
	if(!T)
		return NULL;
	if(T->data == key)
		return T;
	if(T->data > key )
		return _Search(T->lchild,key);
	else
		return _Search(T->rchild,key);
}
//获取平衡二叉排序树的深度
template< class ElemType,class KeyType>
int AVL<ElemType,KeyType>::_GetDepth(AVLNode<ElemType,KeyType>* T)
{
	if(!T)
		return 0;
	switch(T->bf){
	case LH:
		return (1 + _GetDepth(T->lchild));
	case RH:
		return (1 + _GetDepth(T->rchild));
	default:
		return (1 + _GetDepth(T->lchild));
	}
}
//中序遍历二叉树     
template <class ElemType,class KeyType>
void AVL<ElemType,KeyType> ::_InorderTraverse(AVLNode<ElemType,KeyType>* T)
{  
    if(T){
        _InorderTraverse(T->lchild);
        cout << T->data<<" ";
        _InorderTraverse(T->rchild);
        }  
}
#endif
#include <iostream>
#include <string>
using namespace std;
#include "avl.h"
int main()
{
	cout << "---此程序实现平衡二叉树操作---" << endl << endl;
	AVL<int,int> avl;
	int n,x,select;
	bool  flag = 0;
	cout << "请输入要插入的元素个数：";
	cin >> n;
	cout << "请依次输入待插入的元素：";
	while(n--){
		cin >> x;
		avl.Insert(x,x);
	}
	do{
		cout << "请选择操作：1. 插入 2. 删除 3. 查找 4. 显示树的深度 5.中序遍历平衡二叉树 6.退出"<<endl;
		cin >> select;
		switch (select){
		case 1:
			cout << "请输入待插入元素：";
			cin >> x;
			if (!avl.Insert(x,x))
				cout << "   结果：插入失败！";
			else
				cout << "   结果：插入成功！";
			break;
		case 2:
			cout << "请输入待删除元素：";
			cin >> x;
			if (!avl.Delete(x))
				cout <<"   结果：删除失败！";
			else
				cout <<"   结果：删除成功！";
			break;
		case 3:
			cout<<"请输入待查找元素：";
			cin>>x;
			if (!avl.Search(x))
				cout <<"   结果：查找失败！";
			else
				cout <<"   结果：查找成功！";
			break;
		case 4:
			cout << "这棵平衡二叉树深度为：";
			cout << avl.GetDepth();
			cout << endl << endl;
			break;
		case 5:
			cout<<endl<<"该二叉排序树中序遍历为：";
			avl.InorderTraverse();
			cout<<endl<<endl;
			break;
		case 6:
			flag = 1;
			break;
		default:
			flag = 1;
			break;
		}
	} while (flag == 0);
	return 0;
}


happy曾帅
关注
专栏目录
平衡二叉树判定方法（c++）实现
知其所以然
03-22 1099
平衡二叉树判定方法（c++）实现 -- 欢迎指正-- 平衡二叉树特点： 　　任意一个结点的平衡因子（左子树高度 - 右子树高度）的绝对值不会超过1。 　　下面的方法，若是平衡二叉树，则还会返回树的高度 结点结构： struct node { int data; int height; ...
C++ AVL树（高度平衡的二叉搜索树）
ChanJose的博客
03-25 646
一、思路 1.创建AVL树： 每次输入一个数num，然后用Insert()函数，将num插入到AVL树中。 // 创建AVL平衡树 template <class T> void AVLTree<T>::CreateAVLTree() { T num; cout << "请输入数（以-1结束输入）建立平衡二叉树...
寻找平衡点的俩种方法
WenHaiGo的博客
07-01 2383
o(n2)和o(n) //时间复杂度是n static void equPoint2(){ int[] arr = {2,3,4,5,8,5,9}; int leftSum = arr[0]; int rightSum = 0; for (int i : arr) { rightSum+=i; } for (int i =1; i < arr.length; i++) {
平衡二叉搜索树——红黑树
hahahahahaha5的博客
03-12 713
平衡搜索树——红黑树）一.红黑树的性质1.红黑树的基本性质2.红黑树为何可以将时间复杂度降为O(lgn) 首先，在了解红黑树之前我们应该知道平衡搜索树是一种进阶版的二叉搜索树。可是，普通的二叉搜索树在进行插入，删除等操作时，虽然在树高较低时执行的很快。然而，如果树的高度较高时，执行效率可能并没有链表高。前人们为解决此问题，便有人提出了使搜索树平衡的想法。此后，便出现了各种使搜索树平衡的算法，红黑树便是其中的一种，它可以保证在最坏情况下进行基本动态集合操作的时间复杂度为O(lgn)。 一.红黑树的性质 1.红
AVL树平衡二叉搜索树详解--实现插入
wtl666_6的博客
11-01 5807
平衡二叉搜索树--AVL树
c++实现二叉搜索树（上）
henjdx的博客
06-12 1046
二叉搜索树1.树节点增加key属性，用来比较谁大谁小，key不可以重复2.对于任意一个节点，它的key比左子树的key都大，同时也比右子树的key都小善解人意的小吉猜很多小可爱们看到这些概念都很难一下子就理解了，接下来小吉画一张图，方便大家理解（比起上面👆的概念，小吉认为下面的图比较重要）注：标的数值都是键值最后，小吉来考考你们🧐，看看你们是否是真的了解了二叉搜索树，上图👆键值6的右子树的取值范围（>6&&
数据结构之二叉查找树Java泛型版
Cukor丘克的博客
09-07 674
二叉查找树是父节点的权值比其左子树的权值大又比其右子树的权值小的二叉树。二叉查找树可递归生成，并且每一颗小子树都是二叉查找树。根据二叉查找树的特点对其进行中序遍历会得到一串有序的序列，故又称二叉查找树为二叉排序树。二叉查找树的查找发挥了二叉树的二叉的优势，并且二叉查找树适合对原序列进行插入和删除操作，原始的二分查找是在数组中进行查找操作不适合进行插入和删除操作。
判断二叉树是否为二叉搜索树
明朗晨光的专栏
07-01 5873
利用二叉树递归套路判断是否为二叉搜索树
树结构（二）——二叉搜索树、平衡二叉树、红黑树、B树、B+树
m0_37565948的博客
01-29 2205
本篇博客内容略多，涵盖面比较广，小编也是正在学习中，故读者在发现有错误的说法，欢迎在评论区指出。此外，树结构本身就是一个非常复杂的大家庭，各种规则，各种条件，望大家不要气馁，加油，奥利给。 一、二叉搜索树 二叉搜索树是一种特殊的二叉树，它的特点是： 对于任意一个节点p，存储在p的左子树的中的所有节点中的值都小于p中的值 对于任意一个节点p，存储在p的右子树的...
数据结构实验报告-树-二叉树的字符图形显示程序(半期测试)-实验内容与要求.docx
05-03
这通常涉及到队列数据结构，用于存储待访问的节点。 ```cpp void Bfs(Bit* bt) { queue*> q; // ... 具体的广度优先搜索逻辑 ... } ``` 在输入部分，我们使用`getchar`函数读取字符，直到遇到`NULL`标识符（在...
平衡二叉排序树、AVL树、红黑树、B树、B+树
qq_37997523的博客
03-08 747
1、平衡二叉排序树 　 二叉查找树定义：又称为是二叉排序树（Binary Sort Tree）或二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 　　1) 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 　　2) 若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； 　　3) 左、右子树也分别为二叉排序树； 　　4) 没有键值相等的节点。 ...
二叉排序树(C语言)
weixin_46503238的博客
07-26 937
二叉排序树
C++数据结构算法
MrWilliamVs的专栏
10-25 714
1.vector 底层是数组，连续内存空间，当内存不够时重新申请2倍的空间，原来数据复制过去，原空间清空 2.map multimap STL的关联容器，map不允许key重复，multimap允许key重复。（key- value） 内部元素有序，红黑树可以自动排序（以key为序排列） 底层原理是使用了 红黑树，O（logN）的查找 插入 删除的速度。 3.unordered_map 和 unordered_multimap 和2中两个对外接口基本一致，底层原理不同，key无序， 底层实现为 hash t
基于 python 实现的ios混淆脚本工具
10-01
【作品名称】：基于 python 实现的ios混淆脚本工具 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： . addNative.py 生成oc垃圾代码工具 此脚本会扫描指定目录，给OC文件添加垃圾函数，同时创建垃圾文件到/trash目录。 参数说明 --oc_folder OC_FOLDER OC_FOLDER为OC代码所在目录 --replace替换OC_FOLDER下的原文件，同时原代码会备份到脚本目录下的backup_ios目录。不指定此项垃圾代码只会放到脚本目录下的target_ios/ addNative.py里还有一些配置可以看需求手动修改，如生成垃圾文件的数量，垃圾函数的数量，忽略文件列表等，具体请查看代码顶部相关注释 renameNative.py 修改类名前缀工具 类名是引用可能较为复杂 【资源声明】：本资源作为“参考资料”而不是“定制需求”，代码只能作为参考，不能完全复制照搬。需要有一定的基础能够看懂代码，能够自行调试代码并解决报错，能够自行添加功能修改代码。
基于SOM算法对IRIS数据集分类_Learning-Som_IrisClassification.zip
10-01
基于SOM算法对IRIS数据集分类_Learning-Som_IrisClassification
06_摄影展示小程序.zip
最新发布
10-01
我们的小程序源码功能多样，涵盖社交、电商等领域。高度定制化，轻松打造专属风格。用户体验佳，界面美观操作便捷。安全可靠，保障数据与运行稳定。适合创业者、企业和开发者。提供技术支持与文档说明。快来下载，开启精彩之旅！
大学生创业计划书××信息技术公司商业计划书
10-01
大学生创业计划书××信息技术公司商业计划书
朴素贝叶斯分类Iris数据集_Iris-Bayes.zip
10-01
朴素贝叶斯分类Iris数据集_Iris-Bayes
数据结构与冒泡排序：C++实例解析
冒泡排序-b样条曲线拟合是一节关于C++编程中数据结构和算法的教程，主要讲解了冒泡排序算法，并将其应用到实际场景中。本节内容首先介绍了数据结构的基本概念，帮助理解为何学习数据结构对于编程至关重要。 1. 数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值