栈的基本算法 | 易学教程

一、简单介绍
栈是限定进在表尾插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊的含义，成为栈顶(top)，相应地，表头端称为栈底(bottom)。

不含元素的空表称为空栈。栈的修改是按照后进先出的原则进行的，因此，栈又称为后进先出的线性表。

二、栈示意图

三、基本操作

1、栈的初始化: InitStack(&S)
2、栈顶元素插入: Push(&S, &e)
3、栈顶元素获取: GetTop(&S, &e)
4、栈顶元素删除: Pop(&S, &e)
5、栈的长度: StackLength(S)
6、栈的判空: StackEmpty(S)
7、栈元素的访问： StackTraverse(S, visit())
8、栈的清空： ClearStack(&S)
9、栈的销毁： DestroyStack(&S)

四、栈顺序存储的实现

//---------- 栈的顺序存储表示 ---------
#define STACK_INIT_SIZE 100; //存储空间初始分配量
#define STACKINCREMENT  10;  //存储空间分配增量
typedef struct {
    SElemType *base; //在栈构造之前和销毁之后，base的值为NULL
    SElemType *top;  //栈顶指针
    int stacksize;   //当前已分配的存储空间，以元素为单位 
}SqStack;

//---------- 基本操作的函数原型声明 --------
Status InitStack(SqStack &S);    //构造一个空栈S
Status DestroyStack(SqStack &S); //销毁栈S，S不再存在
Status ClearStack(SqStack &S);   //把S置为空栈
Status StackEmpty(SqStack &S);   //若栈S为空栈，则返回TRUE，否则返回FALSE
int StackLength(SqStack &S);     //返回S的元素个数，即栈的长度
Status GetTop(SqStack &S, SElemType &e); //若栈S不空，则用e返回S的栈顶元素，并返回OK，否则返回ERROR
Status Push(SqStack &S, SElemType &e);   //插入元素e为新的栈顶元素
Status Pop(SqStack &S, SElemType &e);    //若栈S不空，则删除S的栈顶元素e，用e返回其值，返回OK，否则返回ERROR
Status StackTraverse(S, visit());        //从栈顶到栈顶依次对每一个元素调用函数visit()。一旦visit()失败，则操作失败

//---------- 基本操作的算法描述 --------
Status InitStack(SqStack &S){
    S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType))
    if(!S.base) exit(OVERFLOW); //存储分配失败
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}

Status DestroyStack(SqStack &S){
    free(S.base);
    S.base = NULL;
    S.top = NULL;
    S.stacksize = 0;
    return OK;
}

Status ClearStack(SqStack &S){
    S.top = S.base;
    return OK;
}

Status StackEmpty(SqStack &S){
    if(S.top = S.base) return TRUE;
    return FALSE;
}

int StackLength(SqStack &S){
    return S.top - S.base;
}

Status GetTop(SqStack &S, SElemType &e){
    if(S.top = S.base) return ERROR;
    e = *(S.top - 1);
    return OK;
}

Status Push(SqStack &S, SElemType &e){
    if(S.top - S.base >= S.stacksize){  //栈满，追加存储空间
        S.base = (SElemType *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));
        if(!S.base) exit(OVERFLOW); //存储分配失败
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT;
    }
    * S.top++ = e;
    return OK;
}

Status Pop(SqStack &S, SElemType &e){
    if(S.top = S.base) return ERROR;
    e = * --S.top;
    return OK;
}

Status StackTraverse(S, visit()){
    while(S.top > S.base)
        visit(*S.base++);
    return OK;
}
Status visit(SElemType e)
{
    printf("%d ", e);
    return OK;
}

五、C语言代码如下

#include<malloc.h>
#include<string.h>
#include<stdio.h>
 
#define OVERFLOW        -1
#define STACK_INIT_SIZE 10
#define STACKINCREMENT 100
#define OK               1
#define ERROR            0
#define TRUE             1
#define FALSE            0
 
typedef int SElemType;
typedef int Status; 
 
struct SqStack
{
    SElemType *base;
    SElemType *top;
    int stacksize;
};
 
Status InitStack(SqStack &S);
Status DestoryStack(SqStack &S);
Status ClearStack(SqStack &S);
Status StackEmpty(SqStack S);
int StackLength(SqStack S);
Status GetTop(SqStack S, SElemType &e);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
Status StackTraverse(SqStack S, Status(*visit)());
 
Status InitStack(SqStack &S)
{
    S.base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
    if(!S.base) return OVERFLOW;
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return OK;
}
 
Status DestoryStack(SqStack &S)
{
    free(S.base);
    S.base = NULL;
    S.top = NULL;
    S.stacksize = 0;
    return OK;
}
 
Status ClearStack(SqStack &S)
{
    S.top = S.base;
    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,SElemType &e)
{
    if(S.top == S.base) return ERROR;
    e = *(S.top -1);
    return OK;
}
 
Status Push(SqStack &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 OVERFLOW;
        S.top = S.base + S.stacksize;
        S.stacksize += STACKINCREMENT; 
    }
    *S.top++ = e;
    return OK;
}
 
Status Pop(SqStack &S, SElemType &e)
{
    if(S.top == S.base) return ERROR;
    e = * --S.top;
    return OK;
}
 
Status StackTraverse(SqStack S, Status(* visit)(SElemType))
{
    while(S.top > S.base)
        visit(*S.base++);
    printf("\n");
    return OK;
}
 
Status visit(SElemType e)
{
    printf("%d ", e);
    return OK;
}
 
int main()
{
    SElemType j;
    SqStack s;
    SElemType e;
 
    if(InitStack(s) == OK)
    for(j = 1; j <= 20; j++)
    {
            Push(s,j);
    }
    printf("栈中的元素依次为：");

    StackTraverse(s,visit);

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

    printf("栈空否：%d(1：是 0：否)\n", StackEmpty(s));

    GetTop(s, e);
    printf("栈顶元素 e=%d 栈的长度为%d\n", e, StackLength(s));

    ClearStack(s);
    printf("清栈后，栈空否：%d(1：空 0：否)\n",StackEmpty(s));

    DestoryStack(s);
    printf("销毁栈后，s.top = %u s.base= %u s.stacksize=%d\n",s.top,s.base,s.stacksize);

    return 0;
}

来源：https://www.cnblogs.com/XYQ-208910/p/11442392.html

标签

return

base

overflow