堆栈

堆栈的抽象数据类型描述

• 数据对象集：一个有0个或多个元素的有穷线性表
• 操作集：长度为MaxSize的堆栈S属于Stack， 堆栈元素iteam属于ElementType

1. Stack CreateStack(int MaxSize): 生成空堆栈，其最大长度为MaxSize
2. int IsFull(Stack S,int MaxSize):判断堆栈S是否已满
3. void Push(Stack S,ElementTyoe item): 将元素item压入堆栈
4. int IsEmpty(Stack S):判断堆栈S是否为空
5. ElementType Pop(Stack S):删除并返回栈顶元素

栈的顺序存储实现

栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成

#define MaxSize 最大存储个数
tyoedef struct SNode *Stack;
struct SNode{
      ElementTyoe Data[MaxSize]'
      int Top;
};

1. 入栈

void Push(Stack PtrS,ElementType item){
      if(PtrS->Top == MaxSize-1){
            printf("堆栈满"); 
            return;
      }
      else{
            PtrS->Data[++(PtrS->Top)]=item;
            return;
       }
}

2. 出栈

ElementType Pop(Stack PtrS){
      if(PtrS->Top==-1){
            printf("堆栈空");
            return ERROR;     //ERROR是ElementType的特殊值 标志错误
      }
      else
            return (PtrS->Data[(PtrS->Top)--]);
}

Eg

用一个数组实现两个堆栈，要求最大地利用数组空间，使数组只要有空间入栈操作就可以成功

#define MaxSize 最大个数
struct DStack{
      ElementType Data[MaxSize];
      int Top1;
      int Top2;
}S;
S.Top1=-1;
S.Top2=MaxSize;

---

从数组两头往里push

void Push(struct DStack *PtrS,ElementType item,int Tag){
      if(PtrS->Top2-PtrS->Top1==1){  //堆栈满
            printf("堆栈满");
            return;
      }
      if(Tag==1)
            PtrS->Data[++(Ptrs->Top1)]=item;
      else
            PtrS->Data[--(PtrS->Top2)]=item;    

ElementType Pop(struct DStack *Ptrs,int Tag){
      if(Tag==1){
            if(PtrS->Top1==-1){
                  printf("堆栈1空"); return NULL;
            }else return PtrS->Data[(PtrS->Top1)--];
      }else{
            if(PtrS->Top2==MaxSize){
                  printf("堆栈2空"); return NULL;
            }else return PtrS->Data[(PtrS->Top2)++];
      }
}

堆栈的链式存储实现

栈的链式存储结构实际上就是一个单链表，叫做链栈，插入和删除操作只能在链栈的栈顶进行

typedef struct SNode *Stack;
struct SNode{
      ElementType Data;
      strucrt SNode *Next;
};

Stack CreateStack(){
      //构建一个堆栈的头结点 返回指针
      Stack S;
      S=(Stack)malloc(sizeof(struct SNode))
      S->Next-NULL;
      return S;
}

int IsEmpty(Stack S){
      //判断堆栈S是否为空，若为空函数返回整数1 否则返回0
      return (S->Next==NULL);

// 将元素item压入堆栈
void Push(ElementType item,Stack S){
      struct SNode *TmpCell;
      TmpCell=(struct SNode*)malloc(sizeof(struct SNode));
      TmpCell->Element=item;
      TmpCell->Next=S->Next;
      S->Next=TmpCell;
}

//删除并返回堆栈S的栈顶元素
ElementType Pop(Stcak S){
      struct SNode *FirstCell;
      ElementType TopElem;
      if(IsEmpty(S)){
            printf("堆栈空"); return NULL;
      }
      else{
            FistCell=S->Next;
            S->Next=FirstCell->Next;
            TopElem=FirstCell->Element;
            free(FirstCell);
            return TopElem;

堆栈应用