堆栈

堆栈
堆栈是后进先出的数据结构，会有一个指向堆栈顶部元素的指针stacktop。
堆栈可以采用数组存储或者链表存储。

template<class T>
class stack{
    virtual ~stack()=0;
    virtual bool empty()=0;
    virtual int size()=0;
    virtual void pop()=0;
    virtual void push(const T& theElement)=0;
    virtual T& top()=0;
}

ArrayStack

堆栈为空时，stacktop=-1。

template<class T>
class arrayStack<T>:public stack{
public:
    stack(int capacity=10){
        arrayLength=capacity;
        element=new T[arrayLength];
        stacktop=-1;
    }
    ~stack(){
        delete [] element;
    }
         //这里没有定义size变量，因为stacktop+1就是栈的大小。因此这里也用
        //stacktop==-1来判断堆栈是否为空。在增加元素的时候要判断栈的大小是不是
        //也到了arraylength，如果是的，就调用chang1Dlength()函数使
        //arrayLength*=2。
    void pop(){
        if(empty()) ...
        element[stacktop--].~T();//即使是数组存储，也要记得调用元素T的析构函数来删除
    }
private:
    int stacktop;
    T* element;
    int arrayLength;
}

LinkedStack

如果把链表的左端作为栈顶，则可以利用链表操作Insert(0,x)和Delete(1,x)来实现堆栈的插入和删除操作。这两种链表操作的时间复杂性均为 O( 1 )。则就stacktop指向链表最左端。

 struct ListNode {
      int val;
      ListNode *next;
      ListNode(int x) : val(x), next(NULL) {}
 };
template<class T>
class LinkedStack:public stack{
public:
    linkedstack(){
        stacktop=NULL;
        size=0;
    }
    //每一个节点都要删除
    ~linkedstack(){
        while(stacktop)
        {
            ListNode* node=stacktop->next;
            delete stacktop;
            stacktop=node;
        }
    }
    void push(const T& theElement){
        stacktop=new ListNode(theElement,stacktop);
        size++;
    }
    void pop()
    {
        ListNode* node=stacktop->next;
        delete stacktop;
        stacktop=node;
    }

private:
    ListNode* stacktop;
    int size;
}