栈的构造

最新推荐文章于 2022-01-20 16:43:38 发布

原创最新推荐文章于 2022-01-20 16:43:38 发布 · 3.5k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#struct #list #存储

<b>┠♀ C ♂┨</b> 专栏收录该内容

4 篇文章

订阅专栏

博客介绍了栈的相关知识。栈是运算受限的线性表，遵循后进先出原则。文中给出了栈的定义，包括栈顶、栈底、空栈等概念，还详细列举了栈的基本运算，如构造空栈、销毁栈、进栈、退栈等。

栈是种特殊的线性表，它们的逻辑结构和线性表相同，只是其运算规则较线性表有更多的限制，故又称它们为运算受限的线性表。栈被广泛应用于各种程序设计中。

栈的定义及基本运算
1、栈的定义
    　栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。
　　(1)通常称插入、删除的这一端为栈顶（Top），另一端称为栈底（Bottom）。
　　(2)当表中没有元素时称为空栈。
　　(3)栈为后进先出（Last In First Out）的线性表，简称为LIFO表。
    　栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中"最新"的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。
2、栈的基本运算
（1）InitStack（S）
    　构造一个空栈S。

（2）DestroyStack ( S )
       消毁一个存在的栈。

（3）ClearStack ( S )
       置空一个存在的栈。

（4）StackEmpty（S）
    　判栈空。若S为空栈，则返回TRUE，否则返回FALSE。
（5）StackFull（S）
    　判栈满。若S为满栈，则返回TRUE，否则返回FALSE。
注意：
　    该运算只适用于栈的顺序存储结构。
（6）Push（S，x）
    　进栈。若栈S不满，则将元素x插入S的栈顶。
（7）Pop（S，e）
    　退栈。若栈S非空，则将S的栈顶元素删去，并返回该元素于e。
（8）StackTop（S,e）
    　取栈顶元素。若栈S非空，则返回栈顶元素于e，但不改变栈的状态。
（9） StackTraverse(S,visit() )
        栈的Visit方法遍历。

/*************************stdlib.h*****************/
#include "stdlib.h"
#include "typedef.h"

typedef int Status;
typedef char SElemType;

typedef struct STACK
{
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;

Status InitStack(SqStack *S);
Status DestroyStack(SqStack *S);
Status ClearStack(SqStack *S);
Status StackEmpty(SqStack S);
Status StackFull(SqStack S);
int StackLength(SqStack S);
SElemType GetTop(SqStack S);
Status Push(SqStack *S,SElemType e);
Status Pop(SqStack *S,SElemType *e);
Status StackPop(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)exit(OVERFLOW);
S->top=S->base;
S->stacksize=STACK_INIT_SIZE;
return OK;
}

Status DestroyStack(SqStack *S)
{
free(S->base);
free(S);
}

Status ClearStack(SqStack *S)
{
S->top=S->base;
}

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

Status StackFull(SqStack S)
{

if((S.(top+S->stacksize)==S.base)&&(S.top+==S.base)) return TRUE;
else
return FALSE;
}

int StackLength(SqStack S)
{
int i;
SElemType *p;
i=0;
p=S.base;
while(p!=S.top){
p++;
i++;
}
return i;
}

SElemType GetTop(SqStack S)
{
if (S.top==S.base) return ERROR;
return *(S.top-1);
}

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 StackTop(SqStack *S,SElemType *e)
{
if(S->top==S->base) return ERROR;
*e=*(S->top);
return OK;
}

Status StackTraverse(SqStack S,Status (*visit)())
{
while(S.top>S.base)
visit(--S.top);
}

/*************************typedef.h*****************/
#define TRUE               1
#define FALSE              0
#define OK                 1
#define ERROR              0
#define INFEASIVLE        -1
#define OVERFLOW          -2
#define LIST_INIT_SIZE   100
#define LISTINCREMENT     10
#define EQUAL              1
#define STACK_INIT_SIZE 100
#define STACKINCREMENT    10
#define MAX              100
#define MAXSIZE          100