栈的顺序存储

Common.h

#ifndef COMMON_H_INCLUDED
#define COMMON_H_INCLUDED

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

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef int ElemType;

#endif // COMMON_H_INCLUDED

Stack_Seq.h

#ifndef STACK_SEQ_H_INCLUDED
#define STACK_SEQ_H_INCLUDED

#include "Common.h"

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef struct {
    ElemType * base;//栈构造之前和销毁之后，base的值为NULL
    ElemType * top;//栈顶指针
    int stacksize;
} SqStack;

Status InitStack(SqStack * s);
Status DestroyStack(SqStack * s);
Status ClearStack(SqStack * s);
Status StackEmpty(SqStack * s);
int StackLength(SqStack * s);
Status GetTop(SqStack * s, ElemType * e);
Status Push(SqStack * s, ElemType e);
Status Pop(SqStack * s, ElemType * e);
void StackTraverse(SqStack * s);

#endif // STACK_SEQ_H_INCLUDED

Stack_Seq.c

#include "Stack_Seq.h"

Status InitStack(SqStack * s)
{
    s->base = (ElemType *)malloc(sizeof(ElemType));
    if(!s->base)
        exit(OVERFLOW);
    s->top = s->base;
    s->stacksize = STACK_INIT_SIZE;
    return OK;
}

Status DestroyStack(SqStack * s)
{
    ClearStack(s);
    free(s->top);
    free(s->base);
    return OK;
}

Status ClearStack(SqStack * s)
{
    ElemType * e = (ElemType *)malloc(sizeof(ElemType));
    while(s->top != s->base)
    {
        Pop(s, e);
    }
    return OK;
}
Status StackEmpty(SqStack * s)
{
    if(s->top == s->base)
        return TRUE;
    else
        return FALSE;
}

int StackLength(SqStack * s)
{
    return (s->top - s->base);
}

Status GetTop(SqStack * s, ElemType * e)
{
    if(s->top == s->base)
        return ERROR;
    else
    {
        *e = *(s->top - 1);
        return OK;
    }
}

Status Push(SqStack * s, ElemType e)
{
    if(StackLength(s) >= s->stacksize)
    {
        s->base = (ElemType *)realloc(s->base, (s->stacksize+STACKINCREMENT)*sizeof(ElemType));
        if(!s->base)
            exit(OVERFLOW);
        s->top = s->base + s->stacksize;
        s->stacksize += STACKINCREMENT;
    }
    *s->top++ = e;
    return OK;
}

Status Pop(SqStack * s, ElemType * e)
{
    if(s->top != s->base)
    {
        *e = *--s->top;
        return OK;
    }
    return ERROR;
}

void StackTraverse(SqStack * s)
{
    if(!StackEmpty(s))
    {
        ElemType * temp = s->top;
        while(temp != s->base)
        {
            temp--;
            printf("%d  ", *temp);
        }
    }
}