链栈和顺序栈的实现

链栈：

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

typedef char NodeData;
typedef struct Node
{
    NodeData data;
    struct Node *next;
}StackNode;


typedef struct
{
    StackNode *top;
}
LinkStack;


//栈置空
void initStack(LinkStack *ls)
{
	ls->top=NULL;
}


//栈判空
int isStackEmpty(LinkStack *ls)
{
    return ls->top==NULL;
}


//进栈
void pushStack(LinkStack *ls,NodeData nodedata)
{
    StackNode *p;
    p=(StackNode *)malloc(sizeof(StackNode));
    p->data=nodedata;
    p->next=ls->top;
    ls->top=p;
}


//出栈
NodeData popStack(LinkStack *ls)
{
    StackNode *p=ls->top;
    NodeData popNode=ls->top->data;
    ls->top=ls->top->next;
    free(p);
    return popNode;
}


//打印栈
void printStack(LinkStack *ls)
{
    int i=0;
    StackNode *node;
    node=ls->top;
    while(node->next!=NULL)
    {
        node=node->next;
        printf("%d = %c\n",i,node->data);
        i++;
    }
}


void main()
{
    LinkStack *ls;
    char inData;
    ls=(LinkStack *)malloc(sizeof(LinkStack));
    initStack(ls);
    printf("输入data\n");
    while(inData != '\n')
    {
        scanf("%c",&inData);
        pushStack(ls,inData);
        printf("%c\n",inData);
    }
    printf("linkStack:\n");
    //打印栈元素
    printStack(ls);
    printf("pop stack\n");
    popStack(ls);
    printStack(ls);
}

顺序栈：

#include <stdio.h>
#include<stdlib.h>
#include <malloc.h>
#define TRUE 1
#define FALSE 0
typedef int SElemType;
typedef int Status;
typedef struct
{
    SElemType *base;
    SElemType *top;
    int stacksize;
}SqStack;

//初始化栈
Status InitStack(SqStack *s)
{
    s->base = (SElemType *)malloc(100 * sizeof(SElemType));
    if (!s->base)
    {
        puts("空间分配失败！");
        return FALSE;
    }
    s->top = s->base;
    s->stacksize = 100;
    return TRUE;
}


//清空栈
Status ClearStack(SqStack *s)
{
    s->top = s->base;
    return TRUE;
}


//判空
Status StackEmpty(SqStack *s)
{
    if (s->top == s->base)
        return TRUE;
    else
        return FALSE;
}


//销毁
Status Destroy(SqStack *s)
{
    free(s->base);
    s->base = NULL;
    s->top = NULL;
    s->stacksize = 0;
    return TRUE;
}


//压栈
Status Push(SqStack *s, SElemType e)
{
    if (s->top - s->base >= s->stacksize)
    {
        s->base = (SElemType *)realloc(s->base, (s->stacksize + 10) * sizeof(SElemType));
        if (!s->base)
        {
            puts("空间分配失败！");
            return FALSE;
        }
        s->top = s->base + s->stacksize;
        //对栈的长度进行修改
        s->stacksize += 10;
    }
    *s->top++ = e;
    return TRUE;
}


//弹栈
Status Pop(SqStack *s, SElemType *e)
{
    if (s->top == s->base) return FALSE;
    //在最后一次入栈完成后，top指针会+1，最后top指针指向的并不是栈顶元素而是栈顶元素上面的空间
    s->top--;
    *e = *(s->top);
    return TRUE;
}


//遍历
Status StackTraverse(SqStack *s)
{
    //此处操作不能改变原栈的结构
    SElemType *b = s->base;
    SElemType *t = s->top;
    while (t > b)
        printf("%d ", *b++);
    printf("\n");
    return TRUE;
}
int main()
{
    SqStack a;
    SqStack *s = &a;
    SElemType e;
    InitStack(s);
    int n;
    printf("输入进栈的元素的个数：");
    scanf("%d", &n);
    while (n--)
    {
        int m;
        scanf("%d", &m);
        Push(s, m);
    }
    StackTraverse(s);
    printf("");
    printf("1进栈后：");
    Push(s, 1);
    StackTraverse(s);
    printf("");
    Pop(s, &e);
    printf("出栈的元素是：%d\n", e);
    StackTraverse(s);
    Destroy(s);
    return 0;
}