【郝斌数据结构自学笔记】30-34_栈的定义_栈的分类_栈程序演示_栈的日常具体应用

30_栈的定义

定义

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

         栈类似于箱子

分类

算法

应用

31_栈的分类

分类

         静态栈

动态栈

32_栈可以执行哪些操作

算法

出栈

压栈

#include<stdio.h>

#include<malloc.h>

voidf(int k)

{

         int m;

         double *q=(double *)malloc(200);

}

 

intmain(void)

{

         int i=10;

         int *p=(int *)malloc(100);//静态的或局部变量分配在栈中分配，动态分配在堆中分配

 

         return 0;

}

33_栈程序演示

#include<stdio.h>

#include<malloc.h>

#include<stdlib.h>

 

typedefstruct Node

{

         int data;

         struct Node *pNext;

}NODE,*PNODE;

 

typedefstruct Stack

{

         PNODE pTop;

         PNODE pBottom;

}STACK,*PSTACK;//PSTACK等价于structSTACK*

 

voidinit(PSTACK);

voidpush(PSTACK,int);

voidtraverse(PSTACK);

boolpop(PSTACK,int *);

boolempty(PSTACK);

voidclear(PSTACK);

 

 

intmain(void)

{

         STACK S;//STACK等价于structStack

         int val;

 

         init(&S);//目的是造出一个空栈

         push(&S,1);

         push(&S,2);

         push(&S,3);

         push(&S,4);

         push(&S,5);

         push(&S,6);

         traverse(&S);//目的是便于输出

         if(pop(&S,&val))

         {

                   printf("出栈成功，出栈的元素是%d\n",val);

         }

         else

         {

                   printf("出栈失败！");

         }       

         traverse(&S);//目的是便于输出

         clear(&S);

         traverse(&S);//目的是便于输出

 

         return 0;

}

 

voidinit(PSTACK pS)

{

         pS->pTop=(PNODE)malloc(sizeof(NODE));

         if(NULL==pS->pTop)

         {

                   printf("动态内存分配失败！\n");

                   exit(-1);

         }

         else

         {

                            pS->pBottom=pS->pTop;

                            pS->pTop->pNext=NULL;//pS->pBottom->pNext=NULL;

         }

 

}

 

voidpush(PSTACK pS,int val)

{

         PNODE pNew=(PNODE)malloc(sizeof(NODE));

         pNew->data=val;

         pNew->pNext=pS->pTop;         //      pS->pTop不能改成pS->pBottom

         pS->pTop=pNew;

 

}

 

voidtraverse(PSTACK pS)

{

         PNODE p=pS->pTop;

         while(p!=pS->pBottom)

         {

                   printf("%d",p->data);

                   p=p->pNext;

         }

         printf("\n");

         return;

}

 

boolempty(PSTACK pS)

{

         if(pS->pTop==pS->pBottom)

         {

                   return true;

         }

         else

         {

                   return false;

         }

}

 

//把pS所指向的栈出栈一次，并把出栈的元素存入pVal形参所指向的变量中，如果出栈失败，返回false，否则返回true

boolpop(PSTACK pS,int * pVal)

{

         if(empty(pS))//pS本身存放的就是S的地址

         {

                   return false;

         }

         else

         {

                   PNODE r=pS->pTop;

                   *pVal=r->data;

                   pS->pTop=r->pNext;

                   free(r);     //内存释放，否则容易造成内存泄露

                   r=NULL;

                  

                   return true;

         }

}

//clear清空

voidclear(PSTACK pS)

{

         if(empty(pS))//pS本身存放的就是S的地址

         {

                   return ;

         }

         else

         {

                   PNODE p=pS->pTop;        

                   PNODE q=NULL;

                   while(p!=pS->pBottom)

                   {

                            q=p->pNext;

                            free(p);

                            p=q;

                   }

                   pS->pTop=pS->pBottom;

         }

}

34_栈的日常具体应用

应用

         函数调用

         中断

         表达式求值

         内存分配

         缓冲处理

         迷宫