动态栈总结

/*链表的应用之一就是栈，栈的操作是简化的单链表的操作
  栈的构造，可以当成是常见单链表的逆序，为什么说栈是
  单链表的简化呢，因为其借助单链表的实现，同时对其操作
  加以限制，即人们常说的“先进后出”，或“后进先出”的
  规则，下面是具体的代码实现。*/

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

//栈的操作通常有栈的初始化、压栈、出栈、遍历栈、清空栈。

/*算法的定义就是对存储数据的操作，即对数据结构的操作，与单链表

  相比，栈可以算是一种算法，不过是一种非常简单的算法，真正的算法

  通常是栈的应用，即表达式求值，函数调用、中断、内存分配、缓冲分配

  以及迷宫，栈的应用将在后续的文章中给出，本章只讲述栈的基本操作。*/

//结点结构体的定义
typedef struct Node{
         int data;                   //数据域
         struct Node *next;  //指针域
}NODE, *PNODE;

//栈的结构体，这是完成栈的操作的必要条件
typedef struct Stack{
          PNODE pTop;            //栈顶指针
          PNODE pBottom;     //栈底指针
}STACK, *PSTACK;

//栈的初始化
void InitStack(PSTACK pst);

//压栈
void PushStack(PSTACK pst, int val);

//出栈
void PopStack(PSTACK pst, int *val);

//判断栈是否为空
bool IsEmpty(PSTACK pst);

//遍历栈
void TraverseStack(PSTACK pst);

//清空栈
void ClearStack(PSTACK pst);

void main(void)
{
       STACK st;
       int val;

       InitStack(&st);

       PushStack(&st, 12);
       PushStack(&st, 1);
       PushStack(&st, 23);
       PushStack(&st, 123);
       PushStack(&st, 45);
       PushStack(&st, 3);

      TraverseStack(&st);

      PopStack(&st, &val);

      TraverseStack(&st);

     ClearStack(&st);

     TraverseStack(&st);

      return;
}

//栈的初始化，即构建一个空栈。
void InitStack(PSTACK pst)
{
        pst->pTop = (PNODE)malloc(sizeof(NODE));
        if (NULL == pst->pTop)
        {
                 printf("分配动态内存失败！\n");
                 exit(-1);
         }
 
         pst->pBottom = pst->pTop;
         pst->pBottom->next = NULL;

         return;
}

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

//压栈
void PushStack(PSTACK pst, int val)
{
         PNODE pNew = (PNODE)malloc(sizeof(NODE));
         if (NULL == pNew)
         {
                 printf("压栈分配内存失败！\n");
                 exit(-1);
         }

         pNew->data = val;
         pNew->next = pst->pTop;
         pst->pTop = pNew;

          return;
}

//遍历栈，输出方式是从顶到底的顺序
void TraverseStack(PSTACK pst)
{
          if (IsEmpty(pst))
         {
              printf("栈为空！\n");
  
               return;
          }
         PNODE p;
         p = pst->pTop;
         while (pst->pBottom != p)
        {
               printf("%d ", p->data);
               p = p->next;
        }
         printf("\n");
 
         return;
}

//出栈，将栈顶的元素输出。
void PopStack(PSTACK pst, int *val)
{
        if (IsEmpty(pst))
        {
              printf("栈为空，无元素可出栈！\n");
  
              return;
        }

       PNODE p;
       p = pst->pTop;
       *val = p->data;
        printf("出栈的元素为：%d\n", *val);
        pst->pTop = p->next;
        free(p);
        p = NULL;

        return;
}

//清空栈
void ClearStack(PSTACK pst)
{
       if (IsEmpty(pst))
      {
             printf("栈为空，无需清空！\n");

             return;
       }

       PNODE p = pst->pTop;
       PNODE q;

       while (pst->pBottom != p)
       {
             q = p->next;
             free(p);
             p = q;
       }

      pst->pTop = pst->pBottom;

       return;

}