笔记六：基于数组的栈的实现

栈

定义：后进先出的数据结构

实现一：基于数组表示的线性表的派生栈的实现。
原理：把线性表的插入和删除操作限制在同一端进行，即得到栈的表现形式。
操作：把数组线性表的右端定义为栈顶。
代码：

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

template<typename T>
class derivedArrayStack : private arrayList<T>, public stack<T>
{
public:
    derivedArrayStack(int initialCapacity = 10) : arrayList<T>(initialCapacity) {}
    bool empty() const { return arrayList<T>::empty(); }
    int size() const { return arrayList<T>::size(); }
    T& top() {
         if (arrayList<T>::size() - 1 < 0)
         {
             cout << "当前栈为空栈！" << endl;
             exit(-1);
         }
        return arrayList<T>::get(arrayList<T>::size() - 1);
    }
    void pop() {
        if (arrayList<T>::size() - 1 < 0)
        {
            cout << "当前栈为空栈,不能进行删除操作！" << endl;
            exit(-1);
        }
        arrayList<T>::erase(arrayList<T>::size() - 1); }
    void push(const T& theElement) { arrayList<T>::insert(arrayList<T>::size(), theElement); }
};

实现二：不以arrayList作为基类，直接实现数组型栈
操作：定义一个指向栈顶的标记stackTop，栈容量标记stackLength和存储数组元素的指针。
代码：

template<typename T>
class arrayStack : public stack<T>
{
public:
    arrayStack(int initialCapacity = 10);
    ~arrayStack() { delete[] stk; }
    bool empty() const { return stackTop == -1; }
    int size() const { return stackTop + 1; }
    T& top();
    void pop();
    void push(const T& theElement);
private:
    int stackTop;   //当前栈顶
    int arrayLength;    //栈容量
    T*  stk;        //元素数组
};

template<typename T>  arrayStack<T>::arrayStack(int initialCapacity)
{
    stackTop = -1;
    arrayLength = initialCapacity;
    stk = new T[arrayLength];
}

template<typename T> T& arrayStack<T>::top()
{
    if (stackTop == -1)
    {
        cout << "当前栈为空栈！" << endl;
        exit(-1);
    }

    return stk[stackTop];
}

template<typename T> void arrayStack<T>::pop()
{
    if (stackTop == -1)
    {
        cout << "当前栈为空栈！" << endl;
        return ;
    }

    //T* curr = stk[stackTop];
    int delTop = stackTop;
    --stackTop;
    stk[delTop].~T();
}

template<typename T> void arrayStack<T>::push(const T& theElement)
{
    if (stackTop == arrayLength - 1)    //达到栈容量，增加栈容量
    {
        T *tmp = new T[arrayLength * 2];
        copy(stk, stk + stackTop, tmp);
        stk = tmp;
        arrayLength = arrayLength * 2;
    }
    stk[++stackTop] = theElement;

}

main()函数：

int main(int argc, char *argv[])
{
    derivedArrayStack<int> DAS;
    DAS.push(5);
    cout << "将元素5入栈后，栈的大小：" << DAS.size() << endl;

    DAS.push(4);
    cout << "将元素4入栈后，栈的大小：" << DAS.size() << endl;

    cout << "返回栈顶元素：" << DAS.top() << "  size = "<<DAS.size()<<endl;

    DAS.pop();
    cout << "删除栈顶元素后新的栈顶元素为：" << DAS.top() << "  size =  " << DAS.size() << endl;

    cout << "\n**********************\n" << endl;

    arrayStack<int> AS;
    AS.push(5);
    cout << "将元素5入栈后，栈的大小：" << " size: "<<AS.size() << endl;

    AS.push(4);
    cout << "将元素4入栈后，栈的大小：" << AS.size() << endl;

    cout << "返回栈顶元素：" << AS.top() << "  size = " << AS.size() << endl;

    AS.pop();
    cout << "删除栈顶元素后新的栈顶元素为：" << AS.top() << "  size =  " << AS.size() << endl;

    return 0;
}

运行：