数据结构-栈的顺序结构两种方式

第一种结构：

　　存储空间有限，适用于知道存储长度的情况下。操作实现很简单。

#include "stdio.h"


#define MAXSIZE 50
#define STACKINCREMENT 10
#define OK 1
#define ERROR 0
typedef int SElemType;
typedef int Status;

typedef struct
{
    SElemType data[MAXSIZE];    //存储数组
    int top;                    //栈顶
}Stack;

//初始化栈
Status InitStack(Stack &S)
{
    S.top = -1;        //栈顶指向-1代表空栈
    return OK;
}

//重置栈为空栈
Status ClearStack(Stack &S)
{
    S.top = -1;    //与初始化一样道理
    return OK;
}

//判断栈是否为空，空栈返回OK 否则返回ERROR
Status StackEmpty(Stack S)
{
    if(S.top < 0)
        return OK;
    else
        return ERROR;
}

//返回栈的长度
int StackLength(Stack S)
{
    return S.top+1;    //因为top值是做数组下标所以比长度小一
}

//若栈不为空 用e返回栈顶数据 并返回OK 否则返回ERROR
Status GetTop(Stack S, SElemType &e)
{
    if(StackEmpty(S))
        return ERROR;
    e = S.data[S.top];
    return OK;
}

//若栈不为空 把e插入栈顶 并返回OK 否则返回ERROR
Status Push(Stack &S, SElemType e)
{
    if(S.top >= MAXSIZE-1)
        return ERROR;
    S.top++;
    S.data[S.top] = e;
    return OK;
}

//若栈不为空 删除栈顶数据 并用e返回值 并返回OK 否则返回ERROR
Status Pop(Stack &S, SElemType &e)
{
    if(StackEmpty(S))
        return ERROR;
    if(StackEmpty(S))
        return ERROR;
    e = S.data[S.top];
    S.top--;
    return OK;
}

//遍历Visit()函数
Status StackTraverse(Stack S, void (* Visit)(SElemType e))
{
    for (int i = 0; i <= S.top; i++)
        Visit(S.data[i]);
    printf("
");
    return OK;
}

//StackTraverse调用函数
//在这里为输出数据
void Visit(SElemType e)
{
    printf("%d ", e);
}

　　因为数据是存储在数组之中，所以没有销毁栈的基本操作函数

第二种结构：

　　相比第一种结构这种方法可以在上限的存储时增加存储容量的大小，使用更加灵活。操作实现依旧简单。

#include "stdio.h"
#include "stdlib.h"

typedef int Status;        //存储空间初始分配
typedef int SElemType;    //存储空间分配增量
#define ERROR 0
#define OK 1
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10

typedef struct
{
    SElemType * base;    //在栈构造之前和销毁之后base的值为NULL
    SElemType * top;    //栈顶指针
    int StackSize;        //当前已分配的存储空间，以元素为单位
}Stack;

//构造一个空栈
Status InitStack (Stack &S)
{
    S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));    //分配基本空间
    if(!S.base)            //判断是否分配成功
        return ERROR;
    S.top = S.base;        //指向栈顶
    S.StackSize = STACKINCREMENT;    //初始链表最大长度
    return OK;
}//InitStack

//销毁一个栈
Status DestroyStack(Stack &S)
{
    free(S.base);            //收回空间
    S.top = S.base = NULL;    //栈顶和base均指向空
    return OK;
}

//重置表为空表
Status ClearStack(Stack S)
{
    S.top = S.base;//栈顶指向首位代表表空
    return OK;
}

//若S为空栈返回OK 否则返回ERROR
Status StackEmpty(Stack S)
{
    if (S.top == S.base)
        return OK;
    else
        return ERROR;
}

//返回栈的长度
int StackLength(Stack S)
{
    SElemType * p = S.base;
    int i = 0;                //计数值为表长
    while(p != S.top)
    {
        p++;
        i++;
    }
    return i;
}

//若栈不空则用e返回栈顶数据并返回OK否则返回ERROR
Status GetTop(Stack S, SElemType &e)
{
    if (StackLength(S) == 0)    //空栈
        return ERROR;
    e = *S.top;    
    return OK;
}

//插入新的栈顶数据
Status Push(Stack &S, SElemType e)
{
    if(S.top - S.base >=S.StackSize)    //空间不足
    {
        S.base = (SElemType *)realloc(S.base, (S.StackSize + STACKINCREMENT) * sizeof(SElemType));
        if(!S.base)
            return ERROR;
        S.top = S.base + S.StackSize;
        S.StackSize += STACKINCREMENT;
    }
    S.top++;
    *S.top = e;
    return OK;
}

//若栈不空 则删除栈顶数据并用e返回且返回OK 否则返回ERROR
Status Pop(Stack &S, SElemType &e)
{
    if(StackLength(S) == 0)    //空栈
        return ERROR;
    e = *S.top;
    S.top--;
    return OK;
}

//对栈遍历Visit()函数
Status StackTraverse(Stack S, void (*Visit)(SElemType e))
{
    SElemType * p = S.base;
    while(p != S.top)
        Visit(*++p);
    printf("
");
    return OK;
}

//StackTraverse调用函数
//在这里做输出栈表用
//顺序为栈底到栈顶
void Visit(SElemType e)
{
    printf("%d ",e);
}

栈是限定仅在表尾进行插入和删除的操作线性表，因此栈的实现比较线性表显得更简单且容易实现。

参考《数据结构（C语言版）》严蔚敏编著