动态栈操作

/*
dynamic_stack.cpp
动态栈操作
1.建栈 2.遍历。3.压栈 4.出栈 5.清栈
by adengou@foxmail.com
2012.07.08
vs2010 和dev++ 5.0编译通过
*/
//#define _CRT_SECURE_NO_DEPRECATE
#include <stdio.h>
#include<stdlib.h>
#include<malloc.h>
// 节点结构
typedef struct Node
{
 int data;
 struct Node *pNext;
}NODE,*PNODE;
//栈的构造
typedef struct Stack
{
 PNODE pTop;
 PNODE pBottom;
}STACK,*PSTACK;
//栈初始化
void initStack(PSTACK);
//显遍历栈
void traversStack(PSTACK);
//压栈
void pushStack(PSTACK pStack,int val);
//出栈
bool popStack(PSTACK,int*);
//判断栈是否为空
bool is_empty(PSTACK) ;
//判断栈是否存在
bool existStack(void);
//清空栈
void clearStack(PSTACK);
//existStk用来判断栈是否存在
PSTACK existStk=NULL;
//销毁栈
bool destroyStack(PSTACK);
int main(void)
{
    int pushVal=0;
    int popVal=0;
    //定义栈 另一种方式:STACK stack
 PSTACK pStack=(PSTACK)malloc(sizeof(PSTACK));

 printf("                                栈操作                       \n");
 printf("               **********************************************\n");
 printf("               ******            菜单选项              ******\n");
 printf("               ******                                  ******\n");
 printf("               ******    1.栈初始化     2.遍历栈       ******\n");
 printf("               ******    3.压栈         4.出栈         ******\n");
 printf("               ******    5.清空栈       6.销毁栈       ******\n");
 printf("               ******    0.退出                        ******\n");
 printf("               ******                                  ******\n");
 printf("               **********************************************\n");

 //栈初始化
// initStack(pStack);
 while(1)
 {
  switch(getchar())
  {
  case '1':

   if(existStk!=NULL)
   {
    printf("栈已存在,你确定建立新栈吗？（Y/N)：");
    if(getchar()=='Y' ||getchar()=='y' )
    {
     initStack(pStack);
     break;
    }
    if(getchar()=='N' ||getchar()=='n' )
    {
     break;
    }

   }
   else
   {
    initStack(pStack);
   }

   break;
  case '2':
   if(!existStack())break;
      if(!is_empty(pStack))
      {
              
       traversStack(pStack);
            }
   break;
  case '3':
     if(!existStack())break;
           printf("请输入压栈值(以'q'结束):");
         while(1)
            {
            scanf("%d",&pushVal);
            if(getchar()=='q')break;
            pushStack(pStack,pushVal);
            }
            printf("压栈成功！\n");
            break;
  case '4':
    if(popStack(pStack,&popVal))
    {
       printf("出栈成功，值为：%d\n",popVal);
    }else{
    printf("出栈不成功！\n");
    
    }

   break;
  case '5':
   clearStack(pStack);
   break;
  case '6':

   if(!destroyStack( pStack))
   {
    printf("销毁不成功!\n");
   }
   break;
  case '0':
   exit(0);
   break;
  default:
   break;
  }
 }
 //释放指向栈的堆指针
 free(existStk);
 existStk=NULL;
    //释放栈
 free(pStack);
 pStack=NULL;
 
 system("pause");
 return 0;
}
//栈是否存在
bool existStack(void)
{
   if(existStk==NULL)
   {
      printf("栈未初始化！\n");
   return false;
   }
   else
   {
       return true;
   }
}
//栈初始化
void initStack(PSTACK pStack)
{
 pStack->pTop=(PNODE)malloc(sizeof(NODE));
 if(pStack->pTop==NULL)
 {
  printf("内存分配失败！\n");
  exit(-1);
 }
 else
 {
  pStack->pBottom=pStack->pTop;
  pStack->pTop->pNext=NULL;
  existStk=pStack;
  printf("栈初始化成功！\n");
 }
}
bool is_empty(PSTACK pStack)
{
 if(pStack->pTop==pStack->pBottom)
 {
    printf("空栈！\n");
       return true;
 }
 else
 {
      
       return false;
 }
}
//压栈
void pushStack(PSTACK pStack,int val)
{
 PNODE pNew=(PNODE)malloc(sizeof(NODE));
 pNew->data=val;
 pNew->pNext=pStack->pTop;
 pStack->pTop=pNew;
 
 return;
}
//遍历
void traversStack(PSTACK pStack )
{
  PNODE pTmp=pStack->pTop;
  printf("当前栈内容是：");
  while(pTmp!=pStack->pBottom)
  {
          printf("%d   ",pTmp->data);
          pTmp=pTmp->pNext;
  }
  printf("\n");
  return;
}
//出栈
bool popStack(PSTACK pStack,int* pVal)
{
    if(!existStack()||is_empty(pStack))
    {
  return false;
 }
 else
 {
     PNODE pNode=pStack->pTop;
     *pVal=pNode->data;
     pStack->pTop=pNode->pNext;
     free(pNode);
     pNode=NULL;
     return true;
    }
}
void clearStack(PSTACK pStack)
{
  if(!existStack()||is_empty(pStack))
     {
   return;
  }
  else
  {
    
   while(pStack->pTop!=pStack->pBottom)
   {
       PNODE pNode=pStack->pTop;
       pStack->pTop=pNode->pNext;
       free(pNode);
       pNode=NULL;    
   }
   printf("清栈完成！\n");
     } 
  return;
}
//销毁栈
bool destroyStack(PSTACK pStack)
{

    if(!existStack())
     {
   return false;
  }
  else
  {
    
   while(pStack->pTop!=pStack->pBottom)
   {
       PNODE pNode=pStack->pTop;
       pStack->pTop=pNode->pNext;
       free(pNode);
       pNode=NULL;    
   }
           
   //free(pStack);
   /*不能在函数中销毁正在操作的栈对象，
   实际上只有一个空栈， 然后把指针指向空，
   内存未释放完，只能算是伪销毁，此问题留
   到以后解决*/
      pStack=NULL;
      existStk=pStack;
      printf("销销成功！\n");
   return true;
        }
}