数据结构基础四-----《线性结构的两种常见应用之一 栈》

线性结构的两种常见应用之一 栈

i.    定义

一种可以实现“先进后出”的存储结构
栈 类似于竹筒倒豆子，最底下的最后倒出来

ii.    分类

静态栈：以数组为内核
动态栈：以链表为内核

iii.    算法(这例讲的是动态栈）

    1.删除元素 pTop向下移一个位置
    2.加入元素 pTop 向上移一个位置
    3.指针pBottom 指向的是 栈底的结点 而这个结点通常没有存储数据，也就是最下面的有效结点的下一个结点，类似于链表的头结点。
    4.如何判断栈是否为空？？pTop == pBottom 时，链栈为空。
    5.链式栈不存在满还是不满的

出栈/入栈图解：

iv.    应用

           函数调用
           中断
           表达式求值
           内存分配
           缓冲处理
           迷宫

示例：实现入栈/出栈操做

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct Node
{
   int data;
   struct Node * pNext;
}NODE,* PNODE;

typedef struct Stack
{
   PNODE pTop;
   PNODE pBottom;
}STACK,* PSTACK;

void init(PSTACK);//PSTACK  等价于struct STACK *
void push(PSTACK,int);
void traverse(PSTACK);
bool pop(PSTACK,int *);
void clear(PSTACK);

int main(void)
{
   int val;//用来保存出栈的元素
   //这句话一执行，内存中就会有一个变量，这个变量具有pTop和pBottom两个成员。
   //但是这里还没有数据因为还没有对他进行初始化。
   STACK S;//STACK  等价于  struct Stack 
   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);

   if(pop(&S,&val))
   {
      printf("出栈成功，出栈的元素是：%d\n",val);
   }
   else
   {	
      printf("出栈失败");
   }
   traverse(&S);//遍历
   clear(&S);
   traverse(&S);
   return 0;
}

void init(PSTACK pS)
{
   pS->pTop = (PNODE)malloc(sizeof(NODE));
   if(pS->pTop ==NULL)
   {
      printf("内存分配失败");
      exit(-1);	
   }
   else
   {
      pS->pBottom  = pS->pTop;
      pS->pTop->pNext = NULL;//pS->pBottom->pNext = NULL;  这两者是等价的。
   }
}

void push(PSTACK pS,int val)
{
   PNODE pNew = (PNODE)malloc(sizeof(NODE));
   pNew ->data = val;
   pNew ->pNext = pS->pTop;//pS->pTop 不能改成pS->pBottom.
   pS->pTop = pNew;
   return;
}
 
void traverse(PSTACK pS)
{
   //定义一个指针p永远指向最顶层的元素  或者说 指向的是 遍历到的最顶上的元素。
   PNODE p = pS->pTop;

   while(p != pS->pBottom)
   {
   printf("   %d",p->data);
   p = p->pNext;
   }
   printf("\n");
   return;
}

bool empty(PSTACK pS)
{
   if(pS->pTop == pS->pBottom)
      return true;
   else
      return false;
}

//把pS 所指向的栈出栈一次，并把出栈的元素存入pVal形参所指向的变量中，
//如果出栈失败，返回false，否则返回true。
bool pop(PSTACK pS,int * pVal)
{
   if(empty(pS))//pS  本身存放的就是 s 的地址。
   {
      return false;
   }else
    {
       //先让pTop 指向栈顶的下一个元素 然后再将r所指向的栈顶元素的内存释放掉。
		
       PNODE r = pS->pTop;
       pS->pTop = r ->pNext;
       *pVal = r->data;
       free(r);
       r = NULL;
       return true;
    }
}

void clear(PSTACK pS)
{
   if(empty(pS))
      return;
   else
   {
      PNODE p = pS->pTop;
      PNODE q = p->pNext;
      while(p != pS->pBottom)
      {
	 q = p->pNext;
	 free(p);
	 p = q;
      }
      pS->pTop = pS->pBottom;
   }	
}