栈

定义一个顺序栈，相当于一个数组，下面的定义也是一样，也可以有其他的定义，比如定义这个栈的大小，指向栈顶的指针，指向栈底的指针，
而下面我的定义为栈的大小，还有int类型的top，用于栈顶指针。

typedef int SElemType  //设置SElemType的类型为int 类型，根据具体情况设置为其他类型
typedef struct
{
    SElemType data[MAXSIZE];    
    int top;
}sqStack;

栈是一种重要的线性结构。

栈，英文名为stack，是一个后进先出的线性表，它在表尾进行插入和删除等操作，这也是它的独特之处。

表尾，是进行插入和删除等操作的地方，也称其为栈的栈顶（top），而表头则称之为栈底（bottom）。

插入和删除等操作，这也是它的独特之处。表尾，是进行插入和删除等操作的地方，也称其为栈的栈顶（top），而表头则称之为栈底（bottom）。

空栈，就是栈中不含任何数据，这个时候栈顶就是栈底。

栈有两种存储方式，一是顺序表存储，二是链表存储。

下面先看看顺序存储的：

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"        //导入相关的头文件

#define    OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20        //定义一些常量

typedef int Status;
typedef int SElemType;

//定义一个顺序栈结构
typedef struct
{
    SElemType data[MAXSIZE];
    int top;
}SqStack;


//输出栈的元素
Status visit(SElemType c)
{
    printf("%d",c);
    return OK;
}

//构造一个空栈S
Status InitStack(SqStack *S)
{
    //当栈有一个元素的时候，top等于0，通常把空栈的判定条件定为top为-1
    S->top=-1;
    return OK;
}

//将S置为空栈
Status ClearStack(SqStack *S)
{
    S->top=-1;
    return OK;
}

//若栈S为空栈，则返回TRUE，如果不是，则返回FALSE
Status StackEmpty(SqStack S)
{
    if(S.top==-1)
        return TRUE;
    else 
        return FALSE;
}

//返回S的元素个数，也就是栈的长度
int StackLength(SqStack S)
{
    return S.top+1;
}

//若栈不为空，则用e返回S的栈顶元素，并返回OK，否则返回FALSE
Status GetTop(SqStack S,SElemType *e)
{
    if(S.top==-1)
        return ERROR;
    else 
        *e=S.data[S.top];
    return OK;
}

//插入元素e为新的栈顶元素
Status Push(SqStack *S,SElemType e)
{
    if(S->top==MAXSIZE-1)    //栈满，要理解这里为什么是减1
    {
        return ERROR;
    }

    S->top++;                //栈顶指针加1，也就是往是移一个位置
    S->data[S->top]=e;        //将新的元素插入
    return OK;
}

//若栈不为空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR
Status Pop(SqStack *S,SElemType *e)
{
    if(S->top==-1)
        return ERROR;
    *e=S->data[S->top];
    S->top--;
    return OK;
}

//从栈底到栈顶依次显示每个栈中的元素
Status StackTraverse(SqStack S)
{
    int i;
    i=0;
    printf("\n");
    while(i<=S.top)
    {
        visit(S.data[i++]);
        printf("\n");
    }
    printf("\n");
    return OK;
}

int main()
{
    int j;
    SqStack s;
    int e;
    if(InitStack(&s)==OK)    //构造栈，初始化,插入元素
    {
        for(j=1;j<=10;j++)
        {
            Push(&s,j);
        }
    }
    printf("栈中的元素依次为:  ");
    StackTraverse(s);        //输出栈中的元素


    Pop(&s,&e);                //删除栈顶元素
    printf("弹出的栈顶元素e=%d\n",e);

    return 0;
}

链式存储的：

//链栈结构的插入删除操作

#include "stdio.h"
#include "stdlib.h"
#include "io.h"
#include "math.h"
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20


typedef int Status;
typedef int SElemType;

//链栈结构
typedef struct StackNode
{
    SElemType data;                //元素的数据
    struct StackNode *next;        //一个指向下一个元素的指针
}StackNode,*LinkStackPtr;

typedef struct
{
    LinkStackPtr top;
    int count;
}LinkStack;


Status visit(SElemType c)
{
    printf("%d",c);
    return OK;
}

//构造空栈
Status InitStack(LinkStack *S)
{
    S->top=(LinkStackPtr)malloc(sizeof(StackNode));
    if(!S->top)
        return ERROR;
    S->top=NULL;
    S->count=0;
    return OK;
}

//把S置为空栈
Status ClearStack(LinkStack *S)
{
    LinkStackPtr p,q;
    p=S->top;
    while(p)
    {
        q=p;
        p=p->next;
        free(q);
    }
    S->count=0;
    return OK;
}

//若栈S为空栈，则返回TRUE，否则返回FALSE
Status StackEmpty(LinkStack S)
{
    if(S.count==0)
        return TRUE;
    else 
        return FALSE;
}

//返回S的元素个数，也就是栈的长度
int StackLength(LinkStack S)
{
    return S.count;
}

//若栈不空，则用e返回s的栈顶元素
Status GetTop(LinkStack S,SElemType *e)
{
    if(S.top==NULL)
        return ERROR;
    else 
        *e=S.top->data;
    return OK;
}

//插入元素e为新的栈顶元素
Status Push(LinkStack *S,SElemType e)
{
    LinkStackPtr s=(LinkStackPtr)malloc(sizeof(StackNode));
    s->data=e;
    s->next=S->top;
    S->top=s;
    S->count++;
    return OK;
}

//若栈不为空，则删除S的栈顶元素，用e返回其值，并返回OK，否则返回ERROR
Status Pop(LinkStack *S,SElemType *e)
{
    LinkStackPtr p;
    if(StackEmpty(*S))
        return ERROR;
    *e=S->top->data;
    p=S->top;
    S->top=S->top->next;
    free(p);
    S->count--;
    return OK;
}

Status StackTraverse(LinkStack S)
{
    LinkStackPtr p;
    p=S.top;
    while(p)
    {
        visit(p->data);
        p=p->next;
        printf("\n");
    }
    printf("\n");
    return OK;
}


int main()
{
    int j;
    LinkStack s;
    int e;
    if(InitStack(&s)==OK)
    {
        for(j=1;j<=10;j++)
        {
            Push(&s,j);
        }
    }
    printf("栈中元素依次为：");
    printf("\n");
    StackTraverse(s);
    Pop(&s,&e);
    printf("弹出的栈顶元素e=%d\n",e);
}