数据结构之栈

//链栈C++描述
#include <iostream>
using namespace std;

struct Node
{
  int data;               //数据域
  Node *next;       //指针域
};


class LinkStack
{
public:
  LinkStack();                     //构造函数，初始化一个空链栈
  ~LinkStack();                    //析构函数，释放链栈各结点的存储空间
  void Push(int x);            //入栈操作，将元素x入栈
  int Pop();                 //出栈操作，将栈顶元素出栈
  int GetTop();              //取栈顶元素（并不删除）
  int Empty();                    //判空操作，判断链栈是否为空栈
private:
  Node *top;                       //栈顶指针即链栈的头指针
};


LinkStack::LinkStack()
{
  top = new Node;                      //生成头结点
  top->data = 0;
  top->next = NULL;                      //头结点的指针域置空
}


LinkStack :: ~LinkStack()
{
  Node *q = NULL;
  while (top != NULL)        //释放链栈的每一个结点的存储空间
  {
    q = top;                 //暂存被释放结点
    top = top->next;         // top指向被释放结点的下一个结点
    delete q;
  }
  q = NULL;
}


int LinkStack::GetTop()
{
  if (top == NULL)
    throw "下溢异常";
  else
    return top->data;
}



void LinkStack::Push(int x)
{
  Node *s = NULL;
  s = new Node; s->data = x;         //申请结点s数据域为x
  s->next = top; top = s;              //将结点s插在栈顶
}


int LinkStack::Pop()
{
  Node *p = NULL;
  int x;
  if (top == NULL) throw "下溢";
  x = top->data; p = top;                //暂存栈顶元素
  top = top->next;                     //将栈顶结点摘链
  delete p;
  return x;
}


int LinkStack::Empty()
{
  if (top->next == NULL)
    return 1;
  else
    return 0;
}

int main()
{
  int x, y, z;
  LinkStack S;                                        //定义链栈变量S
  S.Push(1);
  S.Push(2);
  cout << "取栈顶元素" << S.GetTop()<<endl;
  cout << "栈顶元素出栈" << S.Pop()<<endl;
  if (S.Empty() == 1) cout << "栈为空" << endl;
  else cout << "栈非空" << endl;                    //栈有2个元素，输出栈非空
  return 0;
}



//C语言描述
# 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;  //PSTACK 等价于 struct STACK *

void init(PSTACK);
void push(PSTACK, int );
void traverse(PSTACK);
bool pop(PSTACK, int *);
void clear(PSTACK pS);

int main(void)
{
  STACK S;  //STACK 等价于 struct Stack
  int val;

  init(&S);  //目的是造出一个空栈
  push(&S, 1); //压栈
  push(&S, 2);
  push(&S, 3);
  push(&S, 4);
  push(&S, 5);
  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->data = 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->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
  {
    PNODE r = pS->pTop;
    *pVal = r->data;
    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 = NULL;

    while (p != pS->pBottom)
    {
      q = p->pNext;
      free(p);
      p = q;
    }
    pS->pTop = pS->pBottom;
  }
}