数据结构---栈（C++）

定义：               

     堆栈是通过对线性表的插入和删除操作进行限制而得到的，（即插入和删除操作都必须在表的同一端完成）。因此，堆栈是一个后进先出（last-in-first-out LIFO）的数据结构。

堆栈抽象数据类型描述:

      抽象数据类型Stack

     {

           实例

                   元素线性表，栈底，栈顶

            操作

                   Create():

                   IsEmpty():    若堆栈为空，则返回true，否则返回false

                   IsFull():         若堆栈为满，则返回true，否则返回false

                   Top():            返回栈顶元素，

                   Add(x):         向堆栈中添加元素x，

                   Delete(x):     删除栈顶元素，并将它传递给x 

     }

程序实现：1 顺序存储  2 链式存储
 

顺序存储

    由于栈也是通过对线性表的一种限制而形成的数据结构，因此堆栈的操作也可以利用线性表的操作来实现。所以可以使用派生类和继承的方式来实现对堆栈的操作，然而这种方式的效率低，额外开销高，因此通常将Stack定义成一个基类，而不是派生类。

采用数组，自定义Stack

template<class T>
class Stack
{
public:
    Stack(int MaxStackSize = 100); //构造函数，创建堆栈
    ~Stack() {delete[] stack;}
    bool IsEmpty() const {return top == -1;}
    bool IsFull() const {return top == MaxTop;}
    T Top() const;
    Stack<T>& Push(const T& x);
    Stack<T>& Pop(T& x);

private:
    int top; //栈顶
    int MaxTop; //最大栈顶值
    T *stack; //堆栈元素数组
};

// Stack 类构造函数
template<class T>
Stack<T>::Stack(int MaxStackSize)
{
    MaxTop = MaxStackSize - 1;
    stack = new T[MaxStackSize];
    top = -1;
}

//返回栈顶元素
template<class T>
T Stack<T>::Top() const
{
    if(IsEmpty())
        std::cout << "the stack is empty!" << std::endl;
   else
        return stack[top];
}

//添加元素,进栈
template<class T>
Stack<T>& Stack<T>::Push(const T& x)
{
    if(IsFull())
        std::cout << "the stack is full!" << std::endl;
        stack[++top] = x;
     return *this;
}

//删除元素，出栈,将出栈元素保存至x中
template<class T>
Stack<T>& Stack<T>::Pop(T& x)
{
   if(IsEmpty())
       std::cout << "Out of bounds" << std::endl;
       x = stack[top--];
     return *this;
}

      该种方法在有多个堆栈时，显得不那么高效。但是若仅使用两个堆栈时可以采用这种方法。让一个堆栈从数组的起始位置向后眼神，而让另一个堆栈从数组的结束位置向前延伸，这样可以保持空间的利用率和运行效率。

链表表示

         链接表示采用两个模板类，Node与LinkedStack。一个用来表示单个节点，一个用来操作数据。

//前置声明
template<class T> class LinkedStack;

template<class T>
class Node{
      friend LinkedStack<T>;
      private:
           T data;
           Node<T> *link;
};

template<class T>
class LinkedStack{
  public:
      LinkedStack()  {top = 0;}
      ~LinkedStack();
      bool IsEmpty() const {return top == 0;}
      bool IsFull() const;
      T Top() const;
      LinkedStack<T>& Push(const T& x);
      LinkedStack<T>& Pop(T& x);
  private:
     Node<T> *top;
};

//析构函数
template<class T>
LinkedStack<T>::~LinkedStack()
{
     Node<T> *next;
     while(top)
    {
        next = top->link;
        delete top;
        top = next;
     }
}


//判断堆栈是否为满
template<class T>
bool LinkedStack<T>::IsFull() const
{

}

//返回栈顶元素
template<class T>
T LinkedStack<T>::Top() const
{
   if(IsEmpty())
      std::cout << "the stack is empty!" << std::endl;
    return top->data;
}

//进栈，添加元素
template<class T>
LinkedStack<T>& LinkedStack<T>::Push(const T& x)
{
    Node<T> *p = new Node<T>;
    p->data = x;
    p->link = top;
    top = p;
    return *this;
}


//进栈，添加元素
template<class T>
LinkedStack<T>& LinkedStack<T>::Push(const T& x)
{
    Node<T> *p = new Node<T>;
    p->data = x;
    p->link = top;
    top = p;
    return *this;
}

//出栈，删除元素
template<class T>
LinkedStack<T>& LinkedStack<T>::Pop(T& x)
{
    if(IsEmpty())
       std::cout << "the stack is empty!" << std::endl;
    x = top->data;
    Node<T> *p = top;
    top = top->link;
    delete p;
    return *this;
}