顺序栈的操作集（C语言版）

/*
    顺序栈的操作集中包含的操作

    1、初始化顺序栈 S
        Status InitStack_Sq(SqStack &S, int size, int inc);
    2、销毁顺序栈 S
        Status DestroyStack_Sq(SqStack &S); 
    3、判断栈 S 是否空，若空则返回 TRUE，否则 FALSE
        Status StackEmpty_Sq(SqStack S);
    4、清空栈 S
        void ClearStack_Sq(SqStack &S); 
    5、入栈，即将元素 e 压入栈 S
        Status Push_Sq(SqStack &S, ElemType e); 
    6、出栈，即将栈 S 的栈顶元素出栈，并用 e 返回
        Status Pop_Sq(SqStack &S, ElemType &e);
    7、读栈 S 的栈顶元素，并用 e 返回
        Status GetTop_Sq(SqStack S, ElemType &e);

*/

#include<stdio.h>
#include<stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define PERROR -2
typedef int Status;

// 数据元素的类型，使用时需根据问题的需求定义。
typedef int ElemType;

typedef struct{
    ElemType * elem;        //存储空间的基址
    int top;                //栈顶元素的下一个位置，简称栈顶位标
    int size;                //当前分配的存储空间
    int increment;            //扩容时，增加的存储容量
}SqStack;                    //顺序栈

// 1、初始化顺序栈
Status InitStack_Sq( SqStack &S, int size, int inc){
    //分配存储空间
    S.elem = (ElemType * )malloc(size * sizeof(ElemType));
    if(S.elem == NULL) return OVERFLOW;              //空间分配失败
    S.top = 0;                                           //置S为空栈
    S.size = size;                                       //初始容量值
    S.increment = inc;                                   //初始增量值
    return OK;
}

// 2、销毁顺序栈S
Status DestoryStack_Sq(SqStack &S){
    if(S.elem==NULL)return PERROR;    // 参数合法性检验，非法或已销毁，返回不再执行
    free(S.elem);                    //释放为顺序栈分配的空间
    S.elem = NULL;
    S.top = 0;         
    S.size = 0;
    S.increment = 0;
    return OK;
}

// 3、判断顺序栈 S 是否为空
Status StackEmpty_Sq(SqStack S){
    if(S.elem==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误
    if(S.top==0)
        return TRUE;
    else
        return FALSE;
}

// 4、清空顺序栈 S 
Status ClearStack_Sq(SqStack &S){
    if(S.elem==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误
    S.top = 0;                        //将栈顶位标置为栈底，此时将栈为空栈
    return OK;  
}

// 5、入栈操作
Status Push_Sq(SqStack &S, ElemType e)  {  // 元素e压入栈S
    if(S.elem==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误    
    ElemType *newbase;
    if(S.top>=S.size)  {  // 扩容
        newbase =  (ElemType*)realloc(S.elem, (S.size+S.increment)*sizeof(ElemType));
        if(NULL==newbase) return OVERFLOW;
        S.elem = newbase; 
        S.size += S.increment;
    }
    S.elem[S.top] = e;
    S.top++;
    return OK;
}

 
// 6、出栈操作
Status Pop_Sq(SqStack &S, ElemType &e)  {  // S栈顶元素出栈给e 
    if(S.elem==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误
    if(S.top==0){
        return ERROR;
    }
    S.top--;
    e = S.elem[S.top] ;    
    return OK;
}

// 7、读取栈顶元素，并用 e 返回
Status GetTop_Sq(SqStack S, ElemType &e){
    if(S.elem==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误
    if(S.top == 0){
        return ERROR;
    }
    e = S.elem[S.top-1];
    return OK;
}
int main(){
    int i,e,state;
    static SqStack S;
    printf("1.初始化顺序栈\n");
    printf("2.销毁顺序栈\n");
    printf("3.判断顺序栈是否为空\n");
    printf("4.清空顺序栈\n");
    printf("5.将元素压入栈\n");
    printf("6.栈顶元素出栈\n");
    printf("7.取栈顶元素，并返回\n");
    do{
        printf("请输入你要进行的操作：\n");
        scanf("%d",&i);
        switch(i){
            case 1 :
                    state = InitStack_Sq(S, 10,5); 
                    if(state == OK){
                        printf("初始化成功。\n");
                    }else{
                        printf("初始化失败！\n"); 
                    }
                    break;
            case 2 :
                    state = DestoryStack_Sq(S);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else{
                        printf("销毁栈成功。\n"); 
                    }
                    break;
            case 3 :
                    state = StackEmpty_Sq(S);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else if(state == TRUE){
                        printf("栈为空！\n"); 
                    }else if(state == FALSE){
                        printf("栈不为空!\n"); 
                    }
                    break;
            case 4 :
                    state = ClearStack_Sq(S);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else{
                        printf("已为您清空顺序栈。\n");
                    }
                    break;
            case 5 :
                    printf("请输入压入栈元素的值：\n");
                    scanf("%d",&e);
                    state = Push_Sq(S,e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("元素 %d 成功入栈。\n",e); 
                    }else{
                        printf("元素 %d 入栈失败！\n",e); 
                    }
                    break; 
            case 6 :
                    state = Pop_Sq(S, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("元素 %d 成功出栈！\n",e); 
                    }else{
                        printf("栈内没有元素，不能执行出栈操作！\n");
                    }
                    break;
            case 7 :
                    state = GetTop_Sq(S,e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("取出栈顶元素的值为：%d\n",e); 
                    }else{
                        printf("栈内没有元素，不能执行读取栈顶元素操作！\n");
                    }
                    break;
        }
    }while(i>=1&&i<=7);
    return 0;
}