栈

栈

定义：

一种可以实现“先进后出”的存储结构

栈类似于箱子

分类：

静态栈

动态栈

 #include<stdio.h>
 #include<malloc.h>
 #include<stdlib.h> 
 typedef struct Node
 {
     int date;
     struct Node*pNext;
 }NODE,*PNODE;
 ​
 typedef struct Stack
 {
     PNODE pTop;
     PNODE pBottom;
 }STACK,*PSTACK; 
 ​
 void init(PSTACK);
 void push(PSTACK pS,int);
 void traverse(PSTACK);
 bool pop(PSTACK pS ,int*pVal);
 void clear(PSTACK pS);
 int main(void)
 {
     STACK s;
     int val;
     init(&s);
     push(&s,1);//压栈 
     push(&s,2);
     push(&s,3);
     push(&s,4);
     push(&s,5);
     push(&s,6);
     push(&s,7);
     traverse(&s);//遍历 
     clear(&s);
     traverse(&s);//遍历 
     if(pop(&s,&val))
     {
         printf("出栈成功,出栈的元素是%d\n",val);
     }else{
         printf("出栈失败");
     }
     traverse(&s);//遍历 
     
     return 0;
 }
 void init(PSTACK pS)
 {
     pS->pTop=(PNODE)malloc(sizeof(NODE));
     if(NULL==pS->pTop)
     {
         printf("动态分布内存失败\n");
     }
     else
     {
         pS->pBottom=pS->pTop;
         pS->pTop->pNext=NULL;
      } 
 }
 void push(PSTACK pS,int val)
 {
     PNODE pNew=(PNODE)malloc(sizeof(NODE));
     pNew->date=val;
     pNew->pNext=pS->pTop;
     pS->pTop=pNew;
 }
 void traverse(PSTACK pS)
 {
     PNODE p=pS->pTop;
     while(p!=pS->pBottom)
     {
         printf("%d\t",p->date);
         p=p->pNext; 
     }
     printf("\n");
  }
  bool empty(PSTACK pS)
  {
     if(pS->pTop==pS->pBottom)
     {
         return true;
         
      }else{
         return false;
      }
  }
  bool pop(PSTACK pS ,int*pVal)//出栈失败返回false,否则返回true 
  {
     if(empty(pS))
     {
         return false;
      }else{
         PNODE r=pS->pTop;
         *pVal=r->date; 
         pS->pTop=r->pNext;
         free(r);
         r=NULL;
         
         return true;
      }
      
   } 
 //清空数据，框架还在 
 void clear(PSTACK pS)
 {
     if(empty(pS))
     {
         return;
     }else
     {
     PNODE p=pS->pTop;
     PNODE q=NULL;
     while(p!=pS->pBottom)
     {
         q=p->pNext;
         free(p);
         p=q;
     }
     pS->pTop=pS->pBottom;
     }
 ​
 }

栈的应用：

函数调用

中断

表达式求值

内存分配

缓存处理

迷宫