带头结点的链栈操作集（C语言版）

/*
    带头结点的链栈的操作集中包含的操作

    1、初始化链栈S
        Status InitStack_LS(LStack &S);
    2、销毁链栈S
        Status DestroyStack_LS(LStack &S);
    3、判断链栈S是否为空
        Status StackEmpty_LS(LStack S);
    4、清空链栈 S 
        Status ClearStack_LS(LStack &S); 
    5、入栈操作
        Status Push_LS(LStack &S,ElemType e);
    6、出栈操作
        Status Pop_LS(LStack &S,ElemType &e); 
    7、读取栈顶元素，并用 e 返回
        Status GetTop_LS(LStack 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 LSNode{
    ElemType data;            // 数据域 
    struct LSNode* next;    // 指针域 
}LSNode,*LStack;             // 结点和链栈类型 

// 1、初始化链栈S
Status InitStack_LS(LStack &S){
    S = (LSNode*)malloc(sizeof(LSNode));    // 为头结点申请空间 
    if(S==NULL){
        return OVERFLOW;                        // 申请失败，返回 
    }
    S->next = NULL;                                // 为头结点的指针域赋初值 
    return OK;                                    // 初始化成功，返回
}

// 2、销毁链栈S
Status DestroyStack_LS(LStack &S){
    if(S==NULL)return PERROR;    // 参数合法性检验，非法栈不存在，不再执行栈的销毁操作 
    LStack p = S->next;    // 声明临时指针变量 
    LStack q = p;
    while(p!=NULL){
        p = q->next;
        free(q);
        q = p;
    }
    free(S);            // 释放头结点所占空间 
    S = NULL;        // 将 S至空，避免指针悬挂
}

// 3、判断链栈S是否为空
Status StackEmpty_LS(LStack S){
    if(S==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误  
    if( S->next == NULL ){
        return TRUE;
    }else{
        return FALSE;
    }
}

// 4、清空链栈 S 
Status ClearStack_LS(LStack &S){
    if(S==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误 
    S->next = NULL;
    return OK;
}

// 5、入栈操作
Status Push_LS(LStack &S,ElemType e){
    if(S==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误  
    LSNode *t;
    t = (LSNode*)malloc(sizeof(LSNode));      // 为元素e分配新的结点空间
    if(t == NULL) return OVERFLOW;            // 分配失败，返回 
    t->data = e;
    t->next = S->next;
    S->next = t;          // 在栈顶位置插入新结点 
    return OK;
}

 
// 6、出栈 
Status Pop_LS(LStack &S,ElemType &e){
    if(S==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误  
    LSNode *t;                        // 临时保存要出栈的栈顶结点 
    if(S->next==NULL)return ERROR;    // 判断栈 S 是否是空栈 
    t = S->next;                        // t 指向栈顶元素结点 
    e = t->data;                // 用 e 返回栈顶元素值供外界使用 
    S->next = t->next;                // 删除栈顶元素结点，栈顶指针S指向第二个结点 
    free(t);                     // 释放原栈顶结点的空间
    return OK;
}

// 7、读取栈顶元素，并用 e 返回
Status GetTop_LS(LStack S, ElemType &e){
    if(S==NULL)return PERROR;    // 参数合法性检验，非法返回参数错误 
    if(S->next == NULL) return ERROR;
    e = S->next->data;
    return OK;
}

int main(){
    int i, e, state;
    LStack S = NULL;
    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_LS(S);
                    if(state == OK){
                        printf("初始化成功。\n");
                    }else{
                        printf("初始化失败！\n"); 
                    }
                    break;
            case 2 :
                    state = DestroyStack_LS(S);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else{
                        printf("销毁栈成功。\n"); 
                    }
                    break;
            case 3 :
                    state = StackEmpty_LS(S);
                    if(state==PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else if(state==TRUE){
                        printf("链栈为空！\n"); 
                    }else if(state==FALSE){
                        printf("链栈不为空!\n"); 
                    }
                    break;
            case 4 :
                    state = ClearStack_LS(S);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else{
                        printf("已为您清空链栈。\n");
                    }
                    break;
            case 5 :                    
                    printf("请输入压入栈元素的值：\n");
                    scanf("%d",&e);
                    state = Push_LS(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_LS(S, e);
                    if(state == PERROR){
                        printf("请确认参数合法化或者先执行栈的初始化操作！\n"); 
                    }else if(state == OK){
                        printf("元素 %d 成功出栈！\n",e); 
                    }else{
                        printf("栈内没有元素，不能执行出栈操作！\n");
                    }
                    break;
            case 7 :
                    state = GetTop_LS(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;
}