基于c语言线性结构—栈和队列

最新推荐文章于 2024-07-22 09:43:39 发布
最新推荐文章于 2024-07-22 09:43:39 发布
阅读量690 收藏 7
点赞数
分类专栏： c语言 文章标签： 栈 栈链 C语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/venus321/article/details/79342482
版权
本文详细介绍了栈和队列的概念及在C语言中的实现，包括顺序栈、栈链、循环队列和链队。栈是后进先出（LIFO）的数据结构，常用于表达式求值等场景；而队列则是先进先出（FIFO）的数据结构，适用于任务调度等。文中提供了具体的实现代码，并讨论了如何处理满栈和空队列的情况。
摘要由CSDN通过智能技术生成
栈定义

栈(Stack)是限定只能在表的一端(表尾)进行插人或刪除操作的线性表。允许进行插人或删除的这一端称为栈顶(Top);另一端则称栈底(Bottom),不能进行插人或删除。

当栈中没有包含数据元素时，称为空栈。栈非空时，处于栈顶位置的元素称为栈顶元素。向一个栈插人新的元素称为人栈或进栈(Push)，此时，插人的元素成为新的栈顶元素;从找中删除一个元素时，只能删除当前的栈顶元素，称为出栈或退栈(Pop)。

由于栈的插人和删除只能在栈顶进行，最先人栈的元素必定最后出栈，最后人栈的元素最先出栈，因此栈又叫做后进先出(Last In First Out,LIFO)线性表。

这里写图片描述

顺序表的表示与实现

与顺序表类似，顺序栈就是用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。

实现代码
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define  STACK_INITsize 5
#define  STACK_INCREASE 5

typedef struct {
    int *base;
    int *top;
    int stacksize;//分配存储空间
} sqlstack;

int initStack(sqlstack *p){
     p->base = malloc(sizeof(int)*STACK_INITsize);//开辟了STACK_INITsize
     //个int内存单元，p->base指向第一个内存单元。
     if(p->base==NULL){
        return ERROR;
     }
     p->stacksize = STACK_INITsize;
     p->top = p->base;//设置为空栈
     return OK;


}

int EmptyStack(sqlstack *p){
    if(p->base==p->top){
        printf("栈是空栈\n");
    }else{
        printf("栈不是空栈 \n");
    }
     return OK;
}

int pushStack(sqlstack *p,int value){
    if(p->top-p->base>=p->stacksize){
        p->base = realloc(p->base,(p->stacksize+STACK_INCREASE)*sizeof(int));
        if(p->base==NULL){
            return ERROR;
        }
           p->top = p->base+p->stacksize;
           p->stacksize+=STACK_INCREASE;
    }
      p->top++;//栈顶指针加1, p->top指向的是int的内存单元格，所以每次移动一下，指针地址是加上4.
    *(p->top) = value;

    return OK;

  }


  int popStack(sqlstack *p){
      if(p->top==p->base){//空栈
        return ERROR;
      }
      p->top--;
      printf("出栈一个元素 \n");
      return OK;
  }

   int getTop(sqlstack *p){
       if(p->base==p->top){
        return ERROR;
       }
       printf("栈顶的元素: %d \n",*(p->top));
       return OK;
   }

int main()
{
    int choice;
    sqlstack *p = malloc(sizeof(sqlstack));
    int value;
    do{
        printf("1 栈的初始化 \n");
        printf("2 判断栈是否为空 \n");
        printf("3 入栈的操作 \n");
        printf("4 出栈的操作 \n");
        printf("5 取栈顶元素 \n");
        scanf("%d",&choice);
        switch(choice){
        case 1:
            initStack(p);
        break;
        case 2:
            EmptyStack(p);
        break;
        case 3:
            printf("请输入要入栈的值:\n");
            scanf("%d",&value);
            pushStack(p,value);
        break;
        case 4:
            popStack(p);
        break;
        case 5:
            getTop(p);
        break;
        }
    }while(choice>0);

}

这里写图片描述

说明:
(1) 对于顺序栈，入栈时,必须判定栈是否满。栈满时，若顺序栈采用静态的存储表示，则不能再做入栈操作;若采用上述的动态可变长的存储表示,则需要先申请增加存储空间，再入栈。
(2) 出栈和取栈顶元素操作,必须判定栈是否为空，栈空时不能进行出栈或取栈顶元素操作，否则产生错误。

栈链的表示和实现

链栈就是采用链式存储实现的栈，通过栈链用单链表表示。

实现代码
#include <stdio.h>
#include <stdlib.h>
#define ERROR 0
#define OK 1
#define LINKSTACK_INITSIZE 5;

typedef struct {
     int data;
     struct StackNode *next;
} StackNode;


 int initLinkStak(StackNode *p){
      if(p==NULL){
        printf("申请地址失败 \n");
        return ERROR;
      }
      p->next = NULL;
      return OK;
 }

 int EmptyLinkStack(StackNode *p){
        if(p->next==NULL){
           printf("该链栈为空 \n");
        }else{
           printf("该链栈不为空 \n");
        }
        return OK;
 }


 int pushLinkStack(StackNode *p,int value){
     StackNode *newstackNode = malloc(sizeof(StackNode));
     if(newstackNode==NULL){
        return ERROR;
     }
     newstackNode->next = p;
     newstackNode->data = value;
     p = newstackNode;//将新增的节点作为链栈的顶元素
     return p;//返回该节点，不然还是之前的栈顶的元素
 }

 int popLinkStack(StackNode *p){
     if(p->next==NULL){
        printf("是空链栈");
        return OK;
     }
     StackNode *deleteNode =p;
     p = p->next;
     free(deleteNode);
     return p ;//返回删除后栈顶节点，如果不返回，在调用还是原来的栈顶节点已经删除。

 }


 int showLinkStack(StackNode *p){

    while(p->next!=NULL){
        printf("%d",p->data);
        p =p->next;
    }
 }

int main()
{
  int chioce;
  StackNode *p = malloc(sizeof(StackNode));
  int value;
 do{
     printf("1 初始化链栈 \n");
     printf("2 判断是否为空链栈 \n");
     printf("3 链栈的入栈的操作 \n");
     printf("4 链栈的出栈的操作 \n");
     printf("5 链栈的遍历 \n");
     scanf("%d",&chioce);
     switch(chioce){
         case 1:
             initLinkStak(p);
     break;
         case 2:
             EmptyLinkStack(p);
     break;
         case 3:
             printf("输入栈的值:\n");
             scanf("%d",&value);
            p =  pushLinkStack(p,value);
     break;
         case 4:
            p =  popLinkStack(p);
     break;
         case 5:
             showLinkStack(p);
     break;

     }
 }while(chioce>0);
}

这里写图片描述

总结：不管是栈还是栈链，都是基于栈顶的插入和删除，把握栈顶元素的变化。

队列

队列(Queue)是限定只能在表的两端分别进行插人或删除操作的线性表。在队列结构中，数据元素只能从一端(表尾)插人，从另一端(表头)删除。允许插人的一端称为队尾(Rear)，允许删除的一端称为队头(Front)。当队列中没有包含数据元素时，称为空队。向一个队列插人新的元素称为人队(Enqueue),此时，插人的元素成为新的队尾元素;从队列中删除一个元素时,只能删除当前的队头元素，称为出队(Dequeue)。基于队列的这种“先进先出”的结构特点,因而也称为先进先出(First In First Out,FIFO)线性表。

队列的表示和实现可以采用顺序结构存储和链式结构存储。

顺序队列的表示和实现
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10
#define INCREATE 5
#define OK 1
#define ERROR 0

typedef struct SqQueue{
   int *data;
   int front;//队头指针front指向当前的对头元素
   int rear;//队尾指针rear指向当前队尾元素的下一个位置
   //这里书上把它当前指针，实则并不是指针，可以把它当做记录队列中元素的位置信息


} sqQueue;

void InitQueue(sqQueue *p){
    p->data = malloc(MAXSIZE*sizeof(int));
    if(p->data==NULL){
        return ERROR;
    }
    p->front = p->rear=0;
}

void insertQueue(sqQueue *p,int value){
    int position = p->rear;
    if(p->rear==MAXSIZE-1){
        printf("内存地址开辟不够，需要重新动态分配地址 \n");
        p->data  = realloc(p->data,((p->rear-1)+INCREATE)*sizeof(int));
        if(p->data==NULL){
            return ERROR;
        }
    }
    p->data[position] = value;
    p->rear++;
    return OK;
}

void deleteQueue(sqQueue *p){
    if(p->front==p->rear){//空队列不可以出列
        return ERROR;
    }
    p->front++;
    return OK;
}

void emptyQueue(sqQueue *p){
    if(p->front==p->rear){
        printf("这是空队列 \n");
        return ERROR;
    }else{
        printf("不是空队列 \n");
        return OK;
    }
}

void  getHead(sqQueue *p){
        if(p->front==p->rear){
        printf("这是空队列 \n");
        return ERROR;
        }

        printf("这是队头的元素 %d \n",p->data[p->front]);
}

void getRear(sqQueue *p){
        if(p->front==p->rear){
        printf("这是空队列 \n");
        return ERROR;
        }

        printf("这是队尾的元素 %d \n",p->data[p->rear-1]);

}



int main()
{
     int choice;
     int value;
     sqQueue *p = malloc(sizeof(sqQueue));
     if(p==NULL){
        return ERROR;
     }
     do{
        printf("1 初始化队列 \n");
        printf("2 插入队列 \n");
        printf("3 出列 \n");
        printf("4 是否为空队列 \n");
        printf("5 这是队首元素 \n");
        printf("6 这是队尾元素 \n");
        scanf("%d",&choice);
        switch(choice){
        case 1:
            InitQueue(p);
        break;
         case 2:
             scanf("%d",&value);
             insertQueue(p,value);
        break;
         case 3:
             deleteQueue(p);
        break;
         case 4:
             emptyQueue(p);
        break;
         case 5:
             getHead(p);
        break;
         case 6:
             getRear(p);
        break;
        }

     }while(choice>0);

}

这里写图片描述

循环列表

为了解决上面的假溢出的问题，我们有了循环队列。可以看出上面队列，队列中的数组是可以动态分配的，溢出了就会自动分配，所以下面的代码是基于静态数组，提前给出数组容量。

主要的实现思路：将一维数组的最后一个单元和第一个单元连接起来，构成逻辑上的循环数组，此时就称之为循环队列。

如何形成逻辑上的循环，可以去想想24时间制的1点和13点，一个表示白天，一个是夜里，是怎么去记录，时间是12小时一换，所以用时间除以12，看余数。

根据上面的分析，我们就可以知道在上面定义的指针移动就会有变化。

循环列表的实现代码
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
typedef struct LoopQueue{
   int data[10];//选择数组，已经主动分配地址
   int front;
   int rear;
} loopqueue;

int initQueue(loopqueue *p){

   if(p==NULL){
    return ERROR;
   }
   p->front = p->rear=0;
   return OK;

}

int insertQueue(loopqueue *p,int value){
    if((p->rear+1)%10==p->front){
        printf("队列已经满了 \n");
        return ERROR;
    }
    p->data[p->rear] = value;
    p->rear = (p->rear+1)%10;//移动队尾指针
    return OK;
}

int deleteQueue(loopqueue *p){
    if(p->front==p->rear){
    printf("空队列 \n");
    return ERROR;
    }
    p->front  =(p->front+1)%10;

}

int getHead(loopqueue *p){
    if(p->front==p->rear){
    printf("空队列 \n");
    return ERROR;
    }
    printf("这是队首元素 %d\n",p->data[p->front]);

}

int getRear(loopqueue *p){
    if(p->front==p->rear){
    printf("空队列 \n");
    return ERROR;
    }
    printf("这是队尾元素 %d\n",p->data[p->rear-1]);

}
int EmptyLoopQueue(loopqueue *p){
    if(p->front==p->rear){
    printf("空队列 \n");
    return ERROR;
    }else{
    printf("不是空队列 \n");
    }
}

int main()
{
     int choice;
     int value;
     loopqueue *p=malloc(sizeof(loopqueue));
     do{
        printf("1 循环队列初始化 \n");
        printf("2 插入队列 \n");
        printf("3 出列 \n");
        printf("4 是否为空队列 \n");
        printf("5 这是队首元素 \n");
        printf("6 这是队尾元素 \n");
        scanf("%d",&choice);
        switch(choice){
        case 1:
           initQueue(p);
        break;
         case 2:
             scanf("%d",&value);
             insertQueue(p,value);
        break;
         case 3:
            deleteQueue(p);
        break;
         case 4:
            EmptyLoopQueue(p);
        break;
         case 5:
             getHead(p);
        break;
         case 6:
            getRear(p);
        break;
        }

     }while(choice>0);

}

这里写图片描述

需要注意的地方：循环队列初始化空列时，front=rear=0；当队列经过多次出队入队操作后，会出现对头指针和队尾指针在次指向同一个单元，此时队列可能是空列也可能是满列，为处理这样的情况，通过空留一个存储单元的方式来区分队列满或是空。

链队

采用链式存储结构的队列，称之为链队。

实现代码
#include <stdio.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0

typedef struct LinkNode{
      int data;
      struct LinkNode *next;
  }   LinkNode;

typedef struct LinkQueue{
   LinkNode *front;
   LinkNode *rear;
 } LinkQueue;

int initQueue(LinkQueue *p){
    if(p==NULL){
        printf("链表初始化失败 \n");
        return ERROR;
    }
    LinkNode *node;
    node = malloc(sizeof(LinkNode));
    if(node==NULL){
        printf("节点申请失败 \n");
        return ERROR;
    }
    p->front =p->rear = node;
    node->next=NULL;
    return OK;

}

int emptyLinkQueue(LinkQueue *p){
    if(p->front==p->rear){
        printf("这是空链队 \n");
    }else{
        printf("这不是空链队 \n");
    }
    return OK;

}

int insertQueue(LinkQueue *p,int value){
   //因为采用的是链式，没有数量限制，你想要多少都可以，
   //不需要判断列队是否满
   LinkNode *node;
    node = malloc(sizeof(LinkNode));
    if(node==NULL){
        printf("节点申请失败 \n");
        return ERROR;
    }
    p->rear->next = node;//先之前的指针的next指向新的节点
    node->data = value;
    p->rear = node;//把队列的队尾指针指向新添加的节点，这个
    //代码决不能和p->rear->next = node先后顺序有错，否则产生逻辑上的错误。
    node->next=NULL;//最后的一个节点的next必须为空，不然后面无法去作为遍历条件
    return OK;
}

int deleteLinkQueue(LinkQueue *p){
    if(p->rear==p->front){
        printf("空链队 \n");
        return ERROR;
    }
    LinkNode *node = p->front->next;
    if(p->front->next==p->rear){
        p->front->next=NULL;
        p->rear=p->front;//将队列设置为空队列
    }
    p->front->next = node->next;
    return OK;


}

void show(LinkQueue *p){
     if(p->rear==p->front){
        printf("空链队 \n");
        return ERROR;
    }
    LinkNode *node = p->front->next;
    while(node!=NULL){
        printf("%d \n",node->data);
        node = node->next;
    }

}


int main()
{
     int choice;
     int value;
     LinkQueue *p=malloc(sizeof(LinkQueue));
     do{
        printf("1 链队初始化 \n");
        printf("2 插入队列 \n");
        printf("3 出列 \n");
        printf("4 是否为空队列 \n");
        printf("5 遍历 \n");
        scanf("%d",&choice);
        switch(choice){
        case 1:
           initQueue(p);
        break;
         case 2:
             scanf("%d",&value);
            insertQueue(p,value);
        break;
         case 3:
           deleteLinkQueue(p);
        break;
         case 4:
            emptyLinkQueue(p);
        break;
        case 5:
            show(p);
        break;

        }

     }while(choice>0);

}

这里写图片描述

特别需要注意的就是：在出队列的时候，需要两种考虑，有其他节点的时候，和只有一个节点和头结点时候，出队列之后，就是空队列，p->front==p->rear，应该将队列置于空，否则在进操作时，就会发现队尾指针丢失。

venus321
关注
专栏目录
线性结构（C语言）
DreamEmbrace的博客
02-01 318
数据结构C语言学习笔记，以浙大视频课程为参考
【C语言】实现数据结构——栈，队列
weixin_45423515的博客
05-18 2226
栈和队列都常用的数据结构，这里使用C语言实现栈和队列， 一、栈 栈：是一种特殊的线性表，其只允许在一端出数据和入数据，插入数据和删除数据的一端加栈顶，另一端叫栈底。其数据遵守先进后出的原则（Last in First out）。 因为这个特点那么如果进入一段数据是 1 2 3 4 5，那么其出数据就是反的 5 4 3 2 1。 压栈(push):往栈顶插入数据。 出栈(pop):把数据在栈顶删除。 实现： typedef int STdatatype; typedef...
（数据结构&C语言）对链表的认识
XY_Mckevince的博客
11-27 592
线性表的链式存储结构-单链表
C语言-栈和队列
最新发布
m0_73605503的博客
07-22 1234
欢迎来到HanLop博客的C语言数据结构初阶系列。在之前的文章中，我们详细介绍了链表及其操作方法。在本篇文章中，我们将深入探讨栈和队列这两种常见的数据结构。栈和队列虽然都是线性数据结构，但它们在数据的存取方式上有着显著的区别。栈是一种后进先出（LIFO, Last In First Out）的数据结构，而队列则是一种先进先出（FIFO, First In First Out）的数据结构。通过理解和掌握这两种数据结构，您将能更有效地管理数据，并为后续更复杂的数据结构和算法的学习打下坚实的基础。让我们一起开始探
线性队列(c语言实现)
weixin_52416081的博客
07-25 182
头文件 #include<stdio.h> #include<stdlib.h> #ifndef LINKQUEUE_H_ #define LINKQUEUE_H_ typedef struct node{ int data; struct node *next; }linklist; typedef struct{ linklist *front; linklist *real; }linkq,*linkqP; void InitQueue(linkqP q);
线性结构之栈（c语言）
Jason
01-05 210
栈 结构体： typedef struct SNode { int Data[MAXSIZE]; int top; }*Stack; 初始化栈： Stack InitStack(Stack S) { S = (Stack) malloc(sizeof(Stack)); S->top = -1; return S; } 入栈： void Push(Stack S,int a...
数据结构：线性结构（C语言）
过客的博客
08-23 2527
文章目录线性结构线性表什么是线性表线性表的抽象类型描述线性表的实现广义表广义表定义多重链表堆栈什么是堆栈堆栈的抽象数据类型描述堆栈的顺序存储实现堆栈的链式存储实现堆栈的应用队列什么是队列队列的抽象数据类型描述队列的顺序存储实现队列的链式存储实现 线性结构 线性表 什么是线性表 线性表(Linear List):由同类型数据元素构成有序序列的线性结构。 表中元素个数称为线性表的长度。 线性...
C语言 表、栈和队列详解及实例代码
08-31
本文将深入探讨C语言中的三种基础数据结构：表、栈和队列，并提供相关的实例代码。这些数据结构在计算机科学中有着广泛的应用，尤其是在算法设计和数据处理中。 首先，我们来看表（List ADT）。表是一种线性数据...
基于C语言的数据结构-队列queue
06-25
在本主题“基于C语言的数据结构-队列queue”中，我们将深入探讨如何在C语言中实现队列的数据结构。 队列的基本操作包括： 1. **入队**（Enqueue）：将元素添加到队列的末尾。 2. **出队**（Dequeue）：移除并返回...
东北大学数据结构实验C语言顺序表链表栈和队列二叉树图（欧洲旅游）
02-08
本实验系列主要涉及四个关键主题：顺序表、链表、栈和队列以及二叉树，所有这些概念都是用C语言实现的。值得注意的是，尽管标签提及“C++”，但实际内容是基于C语言的。 首先，我们来看顺序表。顺序表是一种线性...
C语言数据结构库（队列，栈，链表，树的增删改查）
07-09
本资料包提供了一套完整的C语言数据结构库，特别关注于队列、栈、链表和树这四种基本数据结构的增删改查操作。 1. 队列：队列是一种先进先出（FIFO）的数据结构，类似于现实生活中的排队。在这个库中，你可以找到...
C语言线性数据结构
weixin_44230855的博客
07-24 419
C语言线性数据结构 最近在学习数据结构 写博客记录一下，很久没写过c语言了，也是现学现用。 线性表的顺序存储结构 *顺序表的三个属性： 1.存储空间的起始位置（数组名data） 2.顺序表最大存储容量（MaxSize） 3.顺序表当前的长度（length） 编译器为vc6 // 头文件 #include <stdio.h> #include <stdlib.h> #include <malloc.h> #include "windows.h" #define M
C语言|数据结构——线性结构（线性表及其实现）
冰小九的博客
11-02 559
线性表（Linear List）主要操作的实现 初始化广义表实际上就是多重链表 多重链表中的结点可能同时隶属多个链 指针域会有多个，例如上面代码行中的Next和SubList两个指针域 但双向链表中包含两个指针域，并不是多重链表基本上树、图这样相对复杂的数据结构都可以采用多重链表方式实现存储。 矩阵 采用典型的多重链表——十字链表来代替二维数组来存储稀疏矩阵 （二维数组存储稀疏矩阵缺点：1.会造成大量空间浪费
数据结构（C语言）2.线性表——队列
wt_nothing的博客
10-15 292
数据结构C语言——队列，队列的相关知识，队列的C语言实现，用栈实现队列，用队列实现栈，循环队列的实现
c语言--栈和队列
weixin_61558111的博客
09-24 1944
栈的入栈和出栈操作 通常用指针top指向栈顶的位置，用指针bottom指向栈底，栈顶指针top动态反映栈的当前位置。栈是一种特殊的线性表，因此栈可采用顺序存储结构存储，也可以使用链式存储结构存储。栈中的数据元素用一个预设的足够长的一维数组来实现：。栈底位置可以设置在数组的任意端点，用来作为栈顶指针。 若现在有一个栈，StackSize是5，则栈的普通情况、空栈、满栈的情况分别如下图所示： 通常将0下标端设为栈底，这样空栈时栈顶指针s->top = -1；入栈时，栈顶指针s->top++；出栈时，s->
C语言---栈和队列
qq_62743629的博客
05-01 3269
严格来说,栈和队列都属于线性表 "一对一" 栈:"先进后出" 队列: "先进先出" 栈 栈只能从一端存取,另一端是封闭的 在栈中,不论是存还是取,都必须遵循"先进后出"的原则 ==>栈是一种只能从表的一端存取数据,且遵循"先进后出"原则的线性存储结构 进栈和出栈 进栈:将数据存储到栈里面去 出栈:将数据从栈中间取出来 栈的实现方法 栈:有点"特殊"的线性存储结构 顺序表==>顺序栈 (顺序存储结构) 链表==>链栈 (链式存储结构)
C语言——栈和队列
super_coders的博客
05-14 475
ps->a我们有两种初始化方法，一种是直接malloc一个空间，可以是四个或者八个对象的空间，也可以像我一样，先不开，等会入栈的时候再开。栈是一种特殊的线性表，限定仅在表尾进行插入和删除的线性表。在进行入栈以前，先把top指向为栈顶的下一个数据，如果指向栈顶数据的话，初始化就不能为0。队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。栈的实现一般使用数组或者链表，因为cpu高速缓存的原因，使用数组也非常ok。希望这篇博客对你有所帮助！头文件：Queue.h。
C语言数据结构——栈和队列
zcxmjw的博客
12-27 377
本篇文章主要带领大家深入了解栈和队列以及相关实现。
数据结构：栈与队列的C语言实现
队列的常见实现有循环队列和链队列。循环队列利用数组的循环特性，避免了空间利用率低的问题；链队列则通过链表结构实现，提供了更好的动态扩展性。队列的基本操作包括入队（enqueue）、出队（dequeue）、判断队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值