堆栈的公式化描述实现

堆栈和队列可能是使用频率最高的数据结构，二者都来自于线性表数据结构（经过某种限制以后）。堆栈数据结构是通过对线性表的插入和删除操作进行限制而得到的（插入和删除操作都必须在表的同一端完成），因此，堆栈是一个后进先出（ last-in-first-out, LIFO）的数据结构。
1、定义
定义 [堆栈] 堆栈（ s t a c k）是一个线性表，其插入（也称为添加）和删除操作都在表的同一端进行。其中一端被称为栈顶（ t o p），另一端被称为栈底（ b o t t o m）。

ADT：

2、公式化描述

堆栈是一种特殊的线性表，因此它可以使用数组或链表实现。使用数组实现即使公式化描述实现。

令栈顶元素存储在 e l e m e n t [ l e n g t h - 1 ]中，栈底元素存储在 e l e m e n t [ 0 ]中。堆栈元素存储在数组s t a c k之中， t o p用于指向栈顶元素。堆栈的容量为 M a x To p + 1 。

3、代码实现

模板类：

(exceotionerror.h见队列的实现：公式化描述)

#ifndef ARRAYSTACK_H
#define ARRAYSTACK_H
#include "exceptionerror.h"

template<class T>
class ArrayStack
{
public:
    ArrayStack(const int& MaxStackSize = 10);
    ArrayStack(T* s, const int& n,const int& MaxStackSize=10);
    ~ArrayStack()
    {
        if (stack!=NULL)
        {
            delete[] stack;
        }
    }
    friend std::ostream& operator<<(std::ostream& output,const ArrayStack<T>& s)
    {
        if (s.IsEmpty())
        {
            output << "Stack is empty" << std::endl;
        }
        else
        {
            for (int i = 0; i <= s.top;++i)
            {
                output << s.stack[i] << " ";
            }
        }

        return output;
    }
    bool IsEmpty()const{ return top == -1; }
    bool IsFull()const{ return top == MaxTop; }
    T Top()const;
    ArrayStack<T>& Add(const T& x);
    ArrayStack<T>& Delete(T& x);
    int Quantity()const
    {
        return top + 1;
    }
private:
    int top;
    int MaxTop;
    T* stack;
};

template<class T>
ArrayStack<T>::ArrayStack(const int& MaxStackSize=10):MaxTop(MaxStackSize-1),top(-1)
{
    stack = new T[MaxStackSize];
}

template<class T>
ArrayStack<T>::ArrayStack(T* s, const int& n,const int& MaxStackSize):MaxTop(MaxStackSize-1),top(n-1)
{
    if (top>MaxTop)
    {
        throw OutofBounds();
    }
    else
    {
        stack = new T[MaxStackSize];
        memcpy(stack, s, n*sizeof(T));
    }
}

template<class T>
T ArrayStack<T>::Top()const
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }
    else
        return stack[top];
    
}

template<class T>
ArrayStack<T>& ArrayStack<T>::Add(const T& x)
{
    if (IsFull())
    {
        throw NoMem();
    }
    else
    {
        stack[++top] = x;
        return *this;
    }
}

template<class T>
ArrayStack<T>& ArrayStack<T>::Delete(T& x)
{
    if (IsEmpty())
    {
        throw OutofBounds();
    }
    else
    {
        x=stack[top--];
        return *this;
    }
}
#endif

测试代码：

#include "ArrayStack.h"

int main()
{
    ArrayStack<int> S;
    std::cout << "S is empty? " << S.IsEmpty() << std::endl;
    S.Add(1);
    S.Add(2);
    S.Add(3);
    S.Add(4);
    S.Add(5);
    S.Add(6);
    std::cout << "S is :" << std::endl;
    std::cout << S;
    std::cout << std::endl;
    std::cout << "Quantity of S is " << S.Quantity() << std::endl;
    int x;
    S.Delete(x);
    std::cout << "Num Deleted is " << x << std::endl;
    std::cout << "S is :" << std::endl;
    std::cout << S;
    std::cout << std::endl;
    std::cout << "Quantity of S is " << S.Quantity() << std::endl;

    int a[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
    ArrayStack<int> S2(a, 8);
    std::cout << "S2 is :" << std::endl;
    std::cout << S2;
    std::cout << std::endl;
    std::cout << "Quantity of S2 is " << S2.Quantity() << std::endl;
    system("pause");
    return 0;

}

输出：