栈的定义，函数，应用

栈的定义：是限定仅在表尾插入和删除操作的线性表

特点：先进后出（先压栈的后出栈）

#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 pS);//创建一个空栈
void push(PSTACK pS, int val);//压栈
void traverse(PSTACK pS);//遍历
bool pop(PSTACK pS, int *pVal);//出栈
bool empty(PSTACK pS);//判断函数是否为空
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);
   traverse(&S);//遍历输出
  /* clear(&S);*/
  if( pop(&S, &val))
  {
    printf("出栈成功！出栈元素是：%d\n",val);

  }
  else
      printf("出栈失败！\n");
   traverse(&S);
   return 0;
}

//当pS->pTop和pS->pBttom两个指向的是同一个变量且变量 ==NULL时为空栈
void init(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->pBttom->pNext = NULL;
  }
}

//压栈
void push(PSTACK pS, int val)
{
  PNODE pNew = (PNODE)malloc(sizeof(NODE));
  pNew->data = val;
  pNew->pNext = pS->pTop;//不能改成p->pBttom;//目的是将pS->pTop中的地址赋给pNew->pNext,这样pNew就指向之前那个空的变量，可能会压进很多元素，pS->pTop为顶端，在栈的上方，所以不能改成p->pBttom
  pS->pTop = pNew;//将pNew挂在pS->pTop后，这样pS->pTop就指向pNew,这样就成功压栈
  return;

}

//遍历输出
void traverse(PSTACK pS)
{
    PNODE p = pS->pTop;
    while(p != pS->pBottom)
    {
        printf("%d ",p->data);
        p = p->pNext;
    }
    printf("\n");
    return;
}
//把pS所指向的栈出栈一次，并把出栈的元素存入pVal形参所指向的变量中
bool pop(PSTACK pS, int *pVal)
{
  if(empty(pS))
  {
    return false;
  }
  else
  {
      PNODE r = pS->pTop;
      *pVal = r->data;
      pS->pTop = r->pNext;
      free(r);
      r = NULL;
      return true;
  }
}

//判断栈是否为空
bool empty(PSTACK pS)
{
    if(pS->pBottom == pS->pTop)
        return true;
    else
        return false;
}

//清空
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;
  }
}

结果：

 

栈的应用：

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