数据结构C-5-栈的建立与实现（顺序栈、链栈）

1.静态顺序栈

#include<stdio.h>
#include<stdlib.h>
#define MAX_STACK_SIZE 100
typedef int ElemType ;
typedef struct Stack{
    ElemType stack_array[MAX_STACK_SIZE];
    int top;
}Stack;
void InitStack(Stack *s);
void StackPush(Stack *s,ElemType e);
void StackPop(Stack *s);
ElemType StackTop(Stack *s);
int StackSize(Stack *s);
int StackEmpty(Stack *s);

int main(void){
    Stack s;
    int d;
    StackPush(&s,1);StackPush(&s,2);StackPush(&s,3);
    d=StackTop(&s);
    printf("此时栈顶元素为%d.\n",d);
    StackPop(&s);
    printf("弹出元素为%d,此时栈顶元素为%d.\n",d,StackTop(&s));
    return 0;
}
//栈的初始化
void InitStack(Stack *s){
    s->top=0;
}
//入栈
void StackPush(Stack *s,ElemType e){
    if(s->top==MAX_STACK_SIZE){
        printf("栈已满\n");
        return;
    }
     s->top++;
    s->stack_array[s->top]=e;
}
//出栈
void StackPop(Stack *s){
    if(s->top==0){
        printf("栈为空，无法操作\n");
        return;
    }
    s->top--;
}
//获取栈顶元素
ElemType StackTop(Stack *s){
    if(s->top==0)
        printf("栈为空\n");
    return s->stack_array[s->top];
}
//获取栈的元素个数
int StackSize(Stack *s){
    return s->top;
}
//是否为空
int StackEmpty(Stack *s){
    return s->top?1:0;
}

2.动态顺序栈

#include<stdio.h>
#include<stdlib.h>
#define MAX_STACK_SIZE 100    //初始存储空间
#define STACKINCREMENT 10  //存储空间增量
typedef int ElemType ;
typedef int Status;
typedef struct Stack{
    ElemType *base;
    ElemType *top;
    int stacksize;
}Stack;
void InitStack(Stack *s);
void DestroyStack(Stack *s);
void ClearStack(Stack *s);
Status StackEmpty(Stack *s);
void StackPush(Stack *s,ElemType e);
void StackPop(Stack *s,ElemType e);
int GetTop(Stack s);
int StackLength(Stack s);
void StackTraverse(Stack s);

int main(void){
    Stack s;
    ElemType e;
    InitStack(&s);
    for(int i=1;i<=6;i++){
        e=2*i-1;
        StackPush(&s,e);
    }
    printf("栈中元素为(从栈顶到栈底以此为)：");
    StackTraverse(s);
    StackPop(&s,e);
    printf( "弹出的栈顶元素为：%d\n", e );
    e=GetTop(s);
    printf( "目前的栈顶元素是：%d， 栈的长度为：%d\n", e,  StackLength(s));
    printf("栈中元素为(从栈顶到栈底以此为)：");
    StackTraverse(s);
    return 0;
}
//初始化
void InitStack(Stack *s){
    s->base=(ElemType*)malloc(sizeof(ElemType));
    if(!s->base)
        exit(-1);
    s->top=s->base;
    s->stacksize=MAX_STACK_SIZE;
}
//销毁
void DestroyStack(Stack *s){
    if(!s->base)
        free(s->base);
    s->base=NULL;
    s->top=NULL;
    s->stacksize=0;
}
//清空
void ClearStack(Stack *s){
    s->top=s->base;
}
//是否为空
int StackEmpty(Stack *s){
    if(s->base==s->top)
        return 1;
    else
        return 0;
}
//进栈
void StackPush(Stack *s,ElemType e){
    if(s->top-s->base>=s->stacksize){
        s->base=(ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(Stack));
        if(!s->base)
            exit(-1);
        s->top=s->base+s->stacksize;
        s->stacksize+=STACKINCREMENT;
    }
    *s->top=e;
    s->top++;
}
//出栈
void StackPop(Stack *s,ElemType e){
    if(s->base==s->top)
        exit(-1);
    s->top--;
    e=*s->top;
}
//取栈顶元素
int GetTop(Stack s){
    if(StackEmpty(&s))
        exit(-1);
    return *(s.top-1);
}
//栈的长度
int StackLength(Stack s){
    return s.top-s.base;
}
//遍历
void StackTraverse(Stack s){
    if(s.base==s.top)
        printf("栈为空\n");
    else{
        ElemType *p;
        p=s.top;
        while(p>s.base){
            p--;
            printf("%d ",*p);
        }
        printf("\n");
    }
}

3.链栈

//带头指针的链栈
#include<stdio.h>
#include<stdlib.h>
typedef int Status;
typedef int ElemType;
//定义结点
typedef struct SNode{
    ElemType data;
    struct SNode *next;
}SNode,*SLNode;
typedef struct Stack{
    SLNode top;//栈顶指针
    int cnt;//元素个数
}SLinkStack;
void InitStack(SLinkStack *s);
int StackEmpty(SLinkStack s);
void ClearStack(SLinkStack *s);
void DestroyStack(SLinkStack *s);
void Push(SLinkStack *s,ElemType e);
void Pop(SLinkStack *s,ElemType *e);
int GetTop(SLinkStack s,ElemType *e);
int StackLength(SLinkStack s);
void Display(SLinkStack s);

int main(void){
    SLinkStack s;
    InitStack(&s);
    ElemType e;
    if(StackEmpty(s))
        printf("栈为空\n");
    printf("将1，2，3，4依此入栈:\n\n");
    Push(&s,1);Push(&s,2);Push(&s,3);Push(&s,4);
    Display(s);
    printf("\n栈的长度为:%d\n",StackLength(s));
    printf("此时栈顶元素为:%d\n",GetTop(s,&e));
    Pop(&s,&e);
    printf("弹出栈顶元素%d后，此时栈的长度为%d,栈顶元素为%d\n",e,StackLength(s),GetTop(s,&e));
    Display(s);
    return 0;
}
//初始化
void InitStack(SLinkStack *s){
    s->top=(SLNode)malloc(sizeof(SNode));
    if(!s->top)
        exit(-1);
    s->top=NULL;
    s->cnt=0;
}
//判断为空
int StackEmpty(SLinkStack s){
    if(s.cnt==0)
        return 1;
    else
        return 0;
}
//清空
void ClearStack(SLinkStack *s){
    SLNode p,q;
    p=s->top;
    while(p){
        q=p;
        p=p->next;
        free(q);
    }
    s->top=NULL;
    s->cnt=0;
}
//销毁
void DestroyStack(SLinkStack *s){
    SLNode p,q;
    p=s->top;
    while(p){
        q=p;
        p=p->next;
        free(q);
    }
    free(s->top);
}
//入栈
void Push(SLinkStack *s,ElemType e){
    SLNode p;
    p=(SLNode)malloc(sizeof(SNode));
    if(!p)//申请新结点失败
        exit(-1);
    p->data=e;//新结点赋值
    p->next=s->top;
    s->top=p;//钩链
    s->cnt++;
}
//出栈
void Pop(SLinkStack *s,ElemType *e){
    SLNode p;
    if(s->top==NULL)
        exit(-1);
    *e=s->top->data;//取栈顶元素
    p=s->top;
    s->top=s->top->next;
    free(p);
    s->cnt--;
}
//获取栈顶元素
int GetTop(SLinkStack s,ElemType *e){
    if(s.top==NULL)
        return 0;
    else
        *e=s.top->data;
    return *e;
}
//表长
int StackLength(SLinkStack s){
    return s.cnt;
}

void Display(SLinkStack s){
    SLNode p=s.top;
    printf("栈中元素为：");
    while(p){
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}