棧的相關知識

線性數據存儲結構的應用爲

1 棧     stack      （系統靜態分配的局部變量）
2 隊列    （動態分配）

棧的定義 ： 一種可以實現“先進後出的存儲結構”，類似於箱子先進去的元素不能先拿出來
分類 ：

           靜態棧
           動態棧

算法 ：

          出棧
          壓棧

應用 ：

     函數調用
     中斷
     內存分配
     緩衝處理
     迷宮

棧基礎操作

# include <stdio.h>
# include <malloc.h>
# include <stdlib.h>
# include <stdbool.h>


typedef  struct Node
{
    int date ;
    struct Node *pNext ;
}   NODE ,*PNODE;

   
typedef   struct Stack     //棧
{
     PNODE pTop;            //棧的頂部
     PNODE pBottom;           // 棧的底部
}  STACK, *pBottom;      //pstack  等價 struct STACK*


void inint  (PSTACK);              //造一個棧
void push    (PSTACk,int );         // 壓棧
void traverse (PSTACK);  
bool pop (PSTACK,int *);         //出棧
void  clear   (PSTACK  ps);


int main ()
{
   STACK S;        //等價於    struct Stact
   int   val;


    init (&S);       //造出一個空棧
    push (&S,1);     //壓棧
    push (&S,2);
    push (&S,3);
    push (&S,4);
    push (&S,6);

    traverse (&S);     //遍歷輸出

    clear   (&S);       //
    
    traverse (&S);


    if (pop(&S,&val))
    {
      printf ("出棧成功，出棧元素是%d \n",val);
    }
    else 
    {
        printf ("出棧失敗  \n");
    }
    traverse (&S);          // 遍歷輸出

     return  0;
}       

      
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->Bottom->pNext=NULL;
   }
}



void push (PSTACK pS, int val)
{
  PNODE pNew=(PNODE)malloc (sizeof (NODE));

  pNew->date=val;
  pNew->pNext=pS->pTop;    //pS->Top不能改爲pS->Bottom
  pS->pTop=pNew;


  return ;
 } 
      
        
void traverse (PSTACK pS)
{

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

  return ;
}

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

//把ps所指向的棧出棧一次，並把出棧元素所指向的變量中，如果出棧失敗，返回false,否則返回true
bool pop (PSTACK pS,int *pVal)
{
  if (empty (pS))    //pS 本身就是S 的地址
  {
     return false ;
   }
   else 
   {
      PNODE r=pS ->pTop;
      *pVal =r->date ;
      pS->pTop =r->date ;
      pS->pTop=r->pNext;
      free (r);
      r=NULL;


      return true ;
    }  
}


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