线性表之栈

 栈的逻辑结构：         

       定义：栈是一种特别的线性表，所以它的逻辑结构和线性表差不多，而栈的特别之处在于是限定仅在表尾进行插入或删除操作的线性表。又称为后进先出的线性表（LIFO结构）。

                                                

            允许插入和删除 的一端称为 栈顶 ( top ) ，另一端称 为 栈底 ( bottom )。

     栈 的数学模型的建立及操作（ADT）

ADT Stack{
             数据对象：D={ai|ai∈ElemSet,i=1,2,3,···,n,n≥0}
             数据关系R1={<ai-1,ai>/ai-1,ai∈D0;i=2,3,·····n}（约定an端为栈顶，a1端为栈底）
             基本操作：
               InitStack(&S) 
         栈的初始化操作
              StackEmpty(S)
               判断栈是否为空
              StackLength(S)
               求栈的元素个数
              GetTop(S,&e)
              取栈顶元素
              Push(&S,e)
              进栈操作
              Pop(&S,e)
              退栈操作
              StackTraverse(S,visit())
              栈的遍历
         }

 

  栈的存储结构：和线性表类似，也有两种，分别为顺序栈和链栈。

          顺序栈：利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指示栈顶元素在顺序栈中的位置。

                                                      

        说明：     base 称为栈底指针，始终指向栈底；

                    当 base = NULL 时，表明栈结构不存在。

                top 为栈顶指针

                    a. top 的初始值指向栈底，即 top=base

                          b.  空栈：当 top=base 时为栈空的标记

                    c.  当栈非空时， top 的位置：指向当前栈 顶元素的 下一个位置

   通常习惯的做法是：先为栈分配一个基本容量(stacksize)，然后在应用过程中，当栈的空间不够使用时在逐渐扩大。

          

                链栈：链栈的操作和线性表类似，在此不再累述。

栈的数据的运算（算法）

       顺序栈具体算法的实现

           1、顺序栈结构的定义

 #define STACK_INIT_SIZE  100;
         #define STACKINCREMENT  10;
         typedef struct {
            SElemType   *base;
            SElemType   *top;
            int   stacksize;
         } SqStack;//当前栈可使用的最大容量
         SqStack   s;

       说明：   • 栈空条件： s. top =s. base   此时不能出栈

                    • 栈满条件： s.top-s.base >= s.stacksize

                    •  进栈操作：* s.top ++=e;   或* s.top =e;  s.top ++;

                    •  退栈操作： e=*-- s.top ； 或 s.top -- ；  e=* s.top ；

         2、栈的初始化操作  

Stat  Staus InitStack (SqStack &S) {
   S.base = (SElemType )malloc(STACK_INIT_SIZE * sizeof(ElemType));
  if (!S.base) return (OVERFLOW);
  S.top=S.base;
  S.stacksize= STACK_INIT_SIZE;
  return OK;
}

  

         3、取栈顶元素

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

           4、退栈操作

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

    具体代码的实现（C）

#include<string.h>
#include<ctype.h>
#include<malloc.h> /* malloc()等 */
#include<stdlib.h> /* atoi() */
#include<process.h> /* exit() */
#define STACK_INIT_SIZE 10 /* 存储空间初始分配量 */
#define STACKINCREMENT 2 /* 存储空间分配增量 */
typedef struct SqStack
{
   int *base; /* 在栈构造之前和销毁之后，base的值为NULL */
   int *top; /* 栈顶指针 */
   int stacksize; /* 当前已分配的存储空间，以元素为单位 */
}SqStack; /* 顺序栈 */


int InitStack(SqStack *S)
{ /* 构造一个空栈S */
   (*S).base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));
   if(!(*S).base)
     exit(-2); /* 存储分配失败 */
   (*S).top=(*S).base;
   (*S).stacksize=STACK_INIT_SIZE;
   return 1;
}

int StackLength(SqStack S)
{ /* 返回S的元素个数，即栈的长度 */
   return S.top-S.base;
}

int GetTop(SqStack S,int *e)
{ /* 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR */
   if(S.top>S.base)
   {
     *e=*(S.top-1);
     return 1;
   }
   else
     return 0;
}

int Push(SqStack *S,int e)
{ /* 插入元素e为新的栈顶元素 */
   if((*S).top-(*S).base>=(*S).stacksize) /* 栈满，追加存储空间 */
   {
     (*S).base=(int *)realloc((*S).base,((*S).stacksize+STACKINCREMENT)*sizeof(int));
     if(!(*S).base)
       exit(-2); /* 存储分配失败 */
     (*S).top=(*S).base+(*S).stacksize;
     (*S).stacksize+=STACKINCREMENT;
   }
   *((*S).top)++=e;
   return 1;
}

int Pop(SqStack *S,int *e)
{ /* 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR */
   if((*S).top==(*S).base)
     return 0;
   *e=*--(*S).top;
   return 1;
}

int StackTraverse(SqStack S,int(*visit)(int))
{ /* 从栈底到栈顶依次对栈中每个元素调用函数visit()。 */
   /* 一旦visit()失败，则操作失败 */
   while(S.top>S.base)
     visit(*S.base++);
   printf("\n");
   return 1;
}


int visit(int c)
{
   printf("%d ",c);
   return 1;
}

void main()
{
   int j;
   SqStack s;
   int e;
   if(InitStack(&s)==1)
     for(j=1;j<=12;j++)
       Push(&s,j);
   printf("栈中元素依次为：");
   StackTraverse(s,visit);
   Pop(&s,&e);
   printf("弹出的栈顶元素 e=%d\n",e);
   GetTop(s,&e);
   printf("栈顶元素 e=%d 栈的长度为%d\n",e,StackLength(s));
}

    链栈具体算法的实现

       参考线性链表，此处省略十万字

    链栈具体代码的实现

       参考线性链表，此处省略十万字