实现栈和队列的不同方法

最新推荐文章于 2022-01-16 19:46:17 发布
最新推荐文章于 2022-01-16 19:46:17 发布
阅读量247 收藏
点赞数
分类专栏： c++ 算法 文章标签： 栈 队列 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36124194/article/details/78074401
版权
算法 同时被 2 个专栏收录
42 篇文章 0 订阅
订阅专栏
c++
39 篇文章 0 订阅
订阅专栏

实现栈和队列的不同方法

本博客通过顺序和链式两种方式分别去实现了栈和队列，仅供参考

//main.cpp
#include <iostream>
#include "source.hpp"
#include "arrayOfStack.hpp"
#include "arrayOfQueue.hpp"
#include "linkOfStack.hpp"
#include "LinkOfQueue.hpp"
#include <string>
using namespace std;

int main(){
	while(1){
		string commend;
		showMenu1();
		cout << "@user: ~$";
		cin >> commend;
		if(commend == "uas") {
			ArrayStack<string> *stack = new ArrayStack<string>();//a stack with data string
			while(1) {
				MenuStack();
				string commendOfArrayOfStack;
				cout << "@user: ~$";
				cin >>  commendOfArrayOfStack;
				if( commendOfArrayOfStack == "pu"){
					cout <<  "Please enter the data(string) you want to push!" << endl;
					cout << "@user: ~$";
					string data;
					cin >> data;
					if(stack->push(data)) {
						cout << "Push success!" << endl;
					} else {
						cout << "Push fail!" << endl;
					}
					cout << endl;
				} else if( commendOfArrayOfStack == "po") {
					if(stack->pop()){
						cout << "Pop success!" << endl;
					} else {
						cout << "Pop fail!" << endl;
					}
					cout << endl;
				} else if( commendOfArrayOfStack == "em") {
					if(stack->empty()){
 						cout << "The stack is empty!" << endl;
				 	} else {
				 		cout << "The stack is not empty!" << endl;
					 }
					 cout << endl;
				} else if( commendOfArrayOfStack == "to") {
					if(stack->empty()){
 						cout << "Warning! The stack is empty! You cannot pop anything!" << endl;
				 	} else {
				 		cout << "Top data is: " << stack->top() << endl;
					 }
					 cout << endl;
				} else if( commendOfArrayOfStack == "si") {
					cout << "The stack size is " << stack->size() << endl;
					cout << endl;
				} else if( commendOfArrayOfStack == "di") {
					stack->display();
				} else if( commendOfArrayOfStack == "q") {
					break;
				} else {
					cout <<  "Commend error!" << endl << endl;
				}
			}
		} else if(commend == "uaq") {
			ArrayQueue<string> *queue = new ArrayQueue<string>();//a queue with data string
			while(1){
				MenuQueue();
				string commendArrayOfQueue;
				cout << "@user: ~$";
				cin >> commendArrayOfQueue;
				if(commendArrayOfQueue == "ap") {
					if(queue->full()) {
						cout << " Warning! The queue is fulled!" << endl;
					} else {
						cout << "Please enter the data you want to append!" << endl;
						cout << "@user: ~$";
						string data;
						cin >> data;
						if(queue->append(data)) {
							cout << "Append success!" << endl;
						} else {
							cout << "Append fail!" << endl;
						}
					}
					cout << endl;
				} else if(commendArrayOfQueue == "se") {
					if(queue->empty()) {
						cout << " Warning! The queue is empty!" << endl;
					} else {
						if(queue->serve()) {
							cout << "Serve success!" << endl;
						} else {
							cout << "Serve fail!" << endl;
						}
					}
					cout << endl;
				} else if(commendArrayOfQueue == "em") {
					if(queue->empty()) {
						cout << "The queue is empty!" << endl;
					} else {
						cout << "The queue is not enpty!" << endl;
					}
					cout << endl;
				} else if(commendArrayOfQueue == "re") {
					if(queue->empty()) {
						cout << "Warning! The queue is empty!" << endl;
					} else {
						cout << queue->retrieve() << endl;
					}
					cout << endl;
				} else if(commendArrayOfQueue == "si") {
					cout << "The queue's size is " << queue->size() << endl;
					cout << endl;
				} else if(commendArrayOfQueue == "di") {
					queue->display();
				} else if(commendArrayOfQueue == "q") {
					break;
				} else {
					cout << "Commend error!" << endl;
				}
				
			}
		} else if(commend == "uls") {
			LinkStack<string> *stack = new LinkStack<string>();//a stack with data string
			while(1) {
				MenuStack();
				string commendOfLinkOfStack;
				cout << "@user: ~$";
				cin >>  commendOfLinkOfStack;
				if( commendOfLinkOfStack == "pu"){
					cout <<  "Please enter the data(string) you want to push!" << endl;
					cout << "@user: ~$";
					string data;
					cin >> data;
					if(stack->push(data)) {
						cout << "Push success!" << endl;
					} else {
						cout << "Push fail!" << endl;
					}
					cout << endl;
				} else if(commendOfLinkOfStack == "po") {
					if(stack->pop()){
						cout << "Pop success!" << endl;
					} else {
						cout << "Pop fail!" << endl;
					}
					cout << endl;
				} else if(commendOfLinkOfStack == "em") {
					if(stack->empty()){
 						cout << "The stack is empty!" << endl;
				 	} else {
				 		cout << "The stack is not empty!" << endl;
					 }
					 cout << endl;
				} else if(commendOfLinkOfStack == "to") {
					if(stack->empty()){
 						cout << "Warning! The stack is empty! You cannot pop anything!" << endl;
				 	} else {
				 		cout << "Top data is: " << stack->top() << endl;
					 }
					 cout << endl;
				} else if(commendOfLinkOfStack == "si") {
					cout << "The stack size is " << stack->size() << endl;
					cout << endl;
				} else if(commendOfLinkOfStack == "di") {
					stack->display();
				} else if(commendOfLinkOfStack == "q") {
					break;
				} else {
					cout <<  "Commend error!" << endl << endl;
				}
			}
		} else if(commend == "ulq") {
			LinkQueue<string> *queue = new LinkQueue<string>();//a queue with data string
			while(1){
				MenuQueue();
				string commendLinkOfQueue;
				cout << "@user: ~$";
				cin >> commendLinkOfQueue;
				if(commendLinkOfQueue == "ap") {
					cout << "Please enter the data you want to append!" << endl;
					cout << "@user: ~$";
					string data;
					cin >> data;
					if(queue->append(data)) {
						cout << "Append success!" << endl;
					} else {
						cout << "Append fail!" << endl;
					}
					cout << endl;
				} else if(commendLinkOfQueue == "se") {
					if(queue->empty()) {
						cout << " Warning! The queue is empty!" << endl;
					} else {
						if(queue->serve()) {
							cout << "Serve success!" << endl;
						} else {
							cout << "Serve fail!" << endl;
						}
					}
					cout << endl;
				} else if(commendLinkOfQueue == "em") {
					if(queue->empty()) {
						cout << "The queue is empty!" << endl;
					} else {
						cout << "The queue is not enpty!" << endl;
					}
					cout << endl;
				} else if(commendLinkOfQueue == "re") {
					if(queue->empty()) {
						cout << "Warning! The queue is empty!" << endl;
					} else {
						cout << queue->retrieve() << endl;
					}
					cout << endl;
				} else if(commendLinkOfQueue == "si") {
					cout << "The queue's size is " << queue->size() << endl;
					cout << endl;
				} else if(commendLinkOfQueue == "di") {
					queue->display();
				} else if(commendLinkOfQueue == "q") {
					break;
				} else {
					cout << "Commend error!" << endl;
				}
				
			}
		} else if(commend == "q") {
			break;
		} else {
			cout << "Commend error!" << endl << endl;
		}
	}
	
	
	return 0;
}


//source.hpp
#include <iostream>
using namespace std;
#ifndef SOURCE_HPP_
#define SOURCE_HPP_

#define MAXCOUNT 10

void showMenu1(){
	cout << "Using ArrayOfStack----------uas" << endl;
	cout << "Using LinkOfStack-----------uls" << endl;
	cout << "Using ArrayOfQueue----------uaq" << endl;
	cout << "Using LinkOfQueue-----------ulq" << endl;
	cout << "Exit------------------------q"  << endl;
}

void MenuStack(){
	cout << "Push------------pu" << endl;
	cout << "Pop-------------po" << endl;
	cout << "Empty-----------em" << endl;
	cout << "Top-------------to" << endl;
	cout << "Size------------si" << endl;
	cout << "Display---------di" << endl;
	cout << "Return----------q" << endl;
}

void MenuQueue(){
	cout << "Append----------ap" << endl;
	cout << "Serve-----------se" << endl;
	cout << "Empty-----------em"  << endl;
	cout << "Retrieve--------re" << endl;
	cout << "Size------------si" << endl;
	cout << "Display---------di" << endl;
	cout << "Return----------q" << endl;
}


#endif


//arrayOfStack.hpp
#include <iostream>
using namespace std;
#ifndef ARRAYOFSTACK_HPP_
#define ARRAYOFSTACK_HPP_

#define MAXCOUNT 10

template <class T>
class ArrayStack{
public:	
	ArrayStack();
	~ArrayStack();
	bool push(T a);
	bool pop();
	T top();
	int size();
	bool empty();
	void display();
private:
	int count;
	T type[MAXCOUNT];
};

template <class T>
ArrayStack<T>::ArrayStack() {
	count = 0;
}

template <class T>
ArrayStack<T>::~ArrayStack() {
	;
}

template <class T>
bool ArrayStack<T>::push(T a) {
	if(count >= 10){
		return false;
	} else {
		type[count++] = a;
		return true;
	}
}

template <class T>
bool ArrayStack<T>::pop() {
	if(empty()){
		return false;
	} else {
		count--;
		return true;
	}
}

template <class T>
T ArrayStack<T>::top() {
	return type[count-1];
}

template <class T>
bool ArrayStack<T>::empty() {
	if(count <= 0) {
		return true;
	} 
	return false;
}

template <class T>
void ArrayStack<T>::display() {
	for(int i = 0; i < count; i++) {
		if(i != count-1) {
			cout << type[i] << " -> ";
		} else{
			cout << type[i];
		}
	}
	cout << endl;
}

template <class T>
int ArrayStack<T>::size(){
	return count;
}



#endif

//LinkOfStack.hpp
#include <iostream>
using namespace std;
#ifndef LINKOFSTACK_HPP_
#define LINKOFSTACK_HPP_

#define maxqueue 10

template <class S>
class Node{
public:
	S data;
	Node<S> *next;
	Node();
	Node(S _data, Node *_next);
};

template <class S>
Node<S>::Node(){
	data = 0;
	next = NULL;
}

template <class S>
Node<S>::Node(S _data, Node *_next) {
	data = _data;
	next = _next;
}


//---------------------------------------------------
//class stack
template <class T>
class LinkStack{
public:
	LinkStack();
	~LinkStack();
	bool empty();
	bool push(T _data);
	bool pop();
	T top();
	int size();
	void display();
private:
	Node<T> *top_node;
};

template <class T>
LinkStack<T>::LinkStack() {
	top_node = NULL;
}

template <class T>
bool LinkStack<T>::empty(){
	if(top_node == NULL){
		return true;
	}
	return false;
}

template <class T>
bool LinkStack<T>::push(T _data) {
	Node<T> *newNode = new Node<T>(_data, top_node);
	if(newNode == NULL){
		return false;
	}
	top_node = newNode;
	return true;
}

template <class T>
bool LinkStack<T>::pop() {
	Node<T> *old_top = top_node;
	if(top_node == NULL){
		return false;
	}
	top_node = old_top->next;
	delete old_top;
	return true;
}

template <class T>
T LinkStack<T>::top() {
	if(top_node == NULL){
		return 0;
	}
	return top_node->data;
}

template <class T>
LinkStack<T>::~LinkStack(){
	while(!empty()){
		pop();
	}
}

template <class T>
int LinkStack<T>::size() {
	int size = 0;
	Node<T> *temp_node = top_node; 
	while(temp_node) {
		size++;
		temp_node = temp_node->next;
	}
	return size;
}

template <class T>
void LinkStack<T>::display() {
	if(empty()) {
		cout << "This queue is empty!" << endl;
	} else {
		Node<T> *temp_node = top_node;
		int count = 0;
		while(temp_node) {
			if(count != size()-1) {
				cout << temp_node->data << " -> ";
				temp_node = temp_node->next;
				count++;
			} else {
				cout << temp_node->data;
				temp_node = temp_node->next;
			}
			
		}
		cout << endl;
	}
	cout << endl;
}


#endif


//arrayOfQueue.hpp
#include <iostream>
using namespace std;
#ifndef ARRAYOFQUEUE_HPP_
#define ARRAYOFQUEUE_HPP_

#define maxqueue 10

template <class T>
class ArrayQueue{
public:
	ArrayQueue();
	bool empty();
	bool full();
	bool serve();
	bool append(T _data);
	T retrieve();
	int size();
	void display();
private:
	int count;
	int front, rear;
	T data[maxqueue];
};

template <class T>
ArrayQueue<T>::ArrayQueue() {
	count = 0;
	front = 0;
	rear = maxqueue-1;
}

template <class T>
bool ArrayQueue<T>::empty() {
	if(count == 0){
		return true;
	}
	return false;
}

template <class T>
bool ArrayQueue<T>::full() {
	if(count == maxqueue) {
		return true;
	} 
	return false;
}

template <class T>
bool ArrayQueue<T>::serve() {
	if(count <= 0) {
		return false;
	}
	count--;
	front = (front+1)%maxqueue;
	return true;
}

template <class T>
bool ArrayQueue<T>::append(T _data) {
	if(count >= maxqueue){
		return false;
	}
	count++;
	rear = (rear+1)%maxqueue;
	data[rear] = _data;
	return true;
}

template <class T>
T ArrayQueue<T>::retrieve() {
	if(count <= 0){
		return 0;
	}
	return data[front];
}

template <class T>
int ArrayQueue<T>::size() {
	return count;
}

template <class T>
void ArrayQueue<T>::display() {
	if(empty()) {
		cout << "This queue is empty!" << endl;
	} else {
		for(int i = 0; i < size(); i++) {
			if(i != size() - 1)
				cout << data[(front+i)%maxqueue] << " -> ";
			else {
				cout << data[(front+i)%maxqueue];
			}
		}
		cout << endl;
	}
	cout << endl;
}

#endif

//LinkOfQueue.hpp
using namespace std;
#include "linkOfStack.hpp"
#ifndef LINKOFQUEUE_HPP_
#define LINKOFQUEUE_HPP_


template <class T>
class LinkQueue{
public:
	LinkQueue();
	~LinkQueue();
//	LinkQueue(const Queue &original);
	bool empty();
	bool append(T data);
	bool serve();
	T retrieve();
	int size();
	void display();
//	void operator=(const Queue &original);
private:
	Node<T> *front, *rear;
	int count;
};

template <class T>
LinkQueue<T>::LinkQueue(){
	front = rear = NULL;
	count = 0;
}

template <class T>
LinkQueue<T>::~LinkQueue() {
	while(front != rear) {
		Node<T> *temp = front;
		front = front->next;
		delete temp;
	}
	delete front;
}

//template <class T>
//LinkQueue<T>::LinkQueue(const Queue &original);

template <class T>
bool LinkQueue<T>::empty() {
	if(count <= 0) {
		return true;
	}
	return false;
}

template <class T>
bool LinkQueue<T>::append(T data) {
	Node<T> *newNode = new Node<T>(data,NULL);
	if(newNode == NULL) {
		return false;
	}
	if(rear == NULL) {
		front = rear = newNode;
	} else {
		rear->next = newNode;
		rear = newNode;
	}
	count++;
	return true;
}

template <class T>
bool LinkQueue<T>::serve() {
	if(front == NULL) {
		return false;
	}
	Node<T> *oldNode = front;
	front = front->next;
	if(front == NULL) {
		rear = NULL;
	}
	delete oldNode;
	count--;
	return true;
}

template <class T>
T LinkQueue<T>::retrieve() {
	return front->data;
}

template <class T>
int LinkQueue<T>::size() {
	return count;
}

template <class T>
void LinkQueue<T>::display() {
	Node<T> *temp = front;
	for(int i=0;i < count; i++) {
		if(i != count-1) {
			cout << temp->data << " -> ";
		} else {
			cout << temp->data;
		}
		temp = temp->next;
	}
	cout << endl;	
}

#endif

Written by Vilin.

更多技术博客：https://vilin.club/

Vilinzz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
队列的两种实现方式
weixin_45646463的博客
12-26 788
一、链表实现队列的操作 首先编写一个节点类 package Queue; public class Node<E> { //节点类 //当前节点 E data; //下一个节点 Node<E> next; //构造方法 public Node(E data) { this.data = data; } } 编写实现类MyQueue，首先定义...
c++ 实现狼人游戏
Vilin的博客
06-01 4821
题目Task实现一个简单的“狼人游戏”通知机制Details角色有：村民，狼人，预言家，女巫，猎人（Uninitialized只用于默认构造函数） 法官呼叫“狼人/预言家/女巫/猎人”，相应角色进行回答 法官呼叫“村民”，全体角色回答HintsobjA.on(objB)表示将objB作为objA的监听者（事件订阅者） 知识点：观察者模式 类与类的关系：关联 C++ enum 类静态变量
反射 reflect 根据方法名得到方法，并根据不同的数据类型参数和不同的返回值类型
05-28
NULL 博文链接：https://topbox163.iteye.com/blog/671073
两种方法实现队列的相关操作
10-10
两种方法实现了队列的操作，链表and容器（容器实现循环队列） 1.实现队列的一种存储结构 2.实现队列的相关操作 3.利用队列的操作特点，借助进队与出队操作完成打印二项式系数的任务（杨辉三角）
队列的几种实现方式
热门推荐
wenpan的博客
09-20 2万+
队列简介： 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 队列是一种最常用的数据结构，也是最重要的一种数据结构，这里介绍三种实现队列的方法： 1.基于链表来实现队列。 2.使用linkedList来实现队列。 3.使用两个...
队列（Queue）的实现及分析
weixin_62226325的博客
01-16 2511
1.队列的介绍： 1) 队列是一个有序列表，可以用数组或是链表来实现。 2) 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出。 3) 我们把向队列中插入元素的过程称为入队(Enqueue)，删除元素的过程称为出队(Dequeue)并把允许入队的一端称为队尾，允许出的的一端称为队头，没有任何元素的队列则称为空队。其一般结构如下： 2.常用关于队列的操作： package com.zejian.structures.Queue; /** * Created by zeji
数据结构之栈与队列的面试题：用两个队列实现一个栈
Chenxi13
04-12 566
首先要用队列实现栈，我们主要的问题是，应该让先入队列的元素后出去，这样就是栈的操作了，那该如何操作呢？ 我们这里的思路是，首先两个队列，起初在入栈的时候插入到任意一个空队列当中即可，接下来，如果入栈应该插入到一个有元素的队列当中去。在出栈的时候，应该把有元素的队列内的前n-1个元素全部入到另一个空队列内部，接着把剩下的最后一个元素出栈即可。 //实现如下 #include &lt;stdi...
Java实现栈和队列面试题
09-03
主要介绍了Java实现栈和队列的面试题，每个例题代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。
Python实现栈和队列的简单操作方法示例
09-18
主要介绍了Python实现栈和队列的简单操作方法,结合实例形式详细分析了Python栈和队列的原理与简单实现技巧,需要的朋友可以参考下
如何使用JavaScript实现栈与队列
10-16
主要介绍了如何使用JavaScript实现栈与队列。栈和队列是web开发中最常用的两种数据结构。绝大多数用户，甚至包括web开发人员，都不知道这个惊人的事实。,需要的朋友可以参考下
利用栈和队列实现迷宫
06-20
通过栈和队列两种不同的方法来实现迷宫问题，队列方法求出的迷宫路径是最短路径
JS实现利用两个队列表示一个栈的方法
11-27
本文实例讲述了JS实现利用两个队列表示一个栈的方法。分享给大家供大家参考，具体如下： 先看原理图： 理清楚思路，再动笔写： <!DOCTYPE html> <html> <head> <title>2 Queue</title&gt...
队列（图文详解以及实现一些常用方法）
tt 博客
05-29 3313
队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头。 队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数 组头上出数据，效率会比较低。 package www.bittech; inter...
栈和队列的对比和实现
wang_xiang_long的博客
06-28 400
栈和队列对比 栈(Stack):限定只能在表的一端进行插入和删除操作的线性表. 队列(Queue):是限定只能在表的一端进行插入,另一端删除操作的线性表. 不同之处在于队列先进先出,栈先进后出. 栈的实现 方法一(数组实现) class Stack: #定义栈 def __init__(self): self.stack=[] self.size=0 def __str__(self):#转化为字符串方便打印 return str(self.
队列的各种实现方式
12-13 342
队列是什么？？？ 　　今天我们来谈一谈队列。 　　队列同样是一种线性表，但其运算受到一定的限制。其限制在于仅允许在队的一段（这里我们把它叫做队尾）进行插入操作，另一端（把它叫做队首）则进行删除操作。 　　这和现实生活中的排队类似，由于有秩序，整个队列遵循先进先出原则。故又把队列称为先进先出表。 　　我们首先用数组对其进行模拟。 队列之数组实现： //数组模拟队列...
优先队列的多种实现方式与比较
qq_45921491的博客
06-17 1090
优先队列 很多情况下，我们需要对一组数据进行处理，处理不同特征的元素 就像电脑处理不同的程序一样，需要为每个元素进行优先级划分，总是处理优先级高的元素或是程序 而这样的数据结构应该支持： 删除最大元素（优先级最高先执行） 插入元素（优先级高的可以进行“插队”） 一些应用场景： 模拟系统：按照时间顺序处理事件 任务调度：键值的优先级决定了应该首先执行哪些任务 数值计算 优先队列可以通过简单的数组，链表，堆来实现 Sort ├─ MaxPQ.java // 通过堆实现优先队列 ├─ OrderedA
队列的三种实现方式
weixin_30721077的博客
11-30 135
普通顺序存储结构 #include <cstdio> #include <iostream> #include <cstring> #include <cstdlib> const int maxSize = 100 ; using namespace std ; typedef struct { int data[maxS...
统计数字出现次数
Vilin的博客
12-24 4734
Description 某次科研调查时得到了n个自然数，每个数均不超过1500000000（1.5*10^9）。已知不相同的数不超过10000个，现在需要统计这些自然数各自出现的次数，并按照自然数从小到大的顺序输出统计结果。 Input 包含多个测试数据，每个包含n+1行： 第1行是整数n，表示自然数的个数。 第2~n+1行每行一个自然数。
Edit Distance(动态规划)
Vilin的博客
11-04 1564
Edit Distance 题目 Given two words word1 and word2, find the minimum number of operations required to convert word1 to word2. You have the following 3 operations permitted on a word: Insert a character ...
Python如何实现栈和队列
最新发布
12-08
Python可以使用列表来实现栈和队列的操作。具体实现方法如下： 1. 栈的实现 栈是一种后进先出（Last-In-First-Out，LIFO）的数据结构。Python中可以使用列表来实现栈的操作，具体实现方法如下： - 入栈：使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值