数据结构复习篇:栈

二、栈

栈是一种“发育不良”的线性表，它具有与线性表相同的存储结构（基于数组的或基于链于的），但栈的“缺陷”－－－不能像线性表那样具有插入、删除操作－－－反而给了它独有的特色。在后面将会发现，递归，可以用栈来实现。 

在时间复杂度上，基于数组的栈AStack和链式栈LStack，在push()、pop()操作上，都是一个时间常数1。在我的测试中，10万次push()和10万次pop()后，基于数组的栈只比链式栈快一秒。但要注意AStack需要预先指定栈元素的最大个数，而LStack是动态分配的，元素个数在理论上不受限。

经常思考，我发现昨天在线性表那篇文章中，有一个设计错误，就是不应该把结点类Node与List类放在一个文件中，这是违反模块化思想的。当我今天的栈中要用到结点时，应该可以很轻松的通过头文件的方式把结点类引到我的代码中。以下是一个最简单的结点类界面（事实上可以采用可用空间表freelist的方式来定义结点类）：

/*
定义常用于链表中的各种结点界面
文件名：NodeInterface.h
*/
#ifndef NODEINTERFACE_H
#define NODEINTERFACE_H

template<class T> class Node    //单端结点，只含有一个指针
{
public:
    T element;
    Node * next;
public:
    Node(const T &eVal, Node * nVal = NULL)
    {
        element = eVal;
        next = nVal;
    }
    Node(Node * nVal = NULL)
    {
        element = 0;
        next = nVal;
    }

};
#endif

以下是栈的界面及两种实现的代码：

 

 /*
 文件名:StackInterface.h
 */
#ifndef STACKINTERFACE_H
#define STACKINTERFACE_H

#include "NodeInterface.h"

 //定义栈的界面
template<class T> class Stack
{
public:
    virtual bool push(const T&) = 0;    //入栈
    virtual bool pop(T&) = 0;    //出栈
    virtual bool topValue(T&) =0;    //栈顶元素值
};

/////////////////////////////////////
//基于数组的栈Array_based Satck
/////////////////////////////////////
template<class T> class AStack :public Stack<T>
{
private:
    int maxSize;    //栈最多能容纳的元素个数
    int top;    //指示栈中元素的实际个数,由于数组从0开始,(top-1)才指示了栈顶元素的下标
    T * listArray;    //array holding stack elements
public:
    AStack(int size = 100)
    {
        maxSize = size;
        top = 0;
        listArray = new T[maxSize];
    }
    ~AStack()
    {
        delete [] listArray;
    }
    bool push(const T &);
    bool pop(T &);
    bool topValue(T &);
    int length() const
    {
        return top;
    }

};

template<class T> bool AStack<T>::push(const T & element)
{
    if (top == maxSize)    //stack is full.
    {
        return false;
    }
    listArray[top] = element;
    ++top;
    return true;
}

template<class T> bool AStack<T>::pop(T & ref_elem)
{
    if (top == 0)    //no element in stack
    {
        return false;
    }
    ref_elem = listArray[--top];
    return true;
}

template<class T> bool AStack<T>::topValue(T & ref_elem)
{
    if (top == 0)    //no element in stack
    {
        return false;
    }
    ref_elem = listArray[top-1];
    return true;
}

///////////////////////////////////
//链式栈 Linked Stack
///////////////////////////////////
template<class T> class LStack :public Stack<T>
{
private:
    int listSize;    //the number of elements,and that is the number of nodes
    Node<T> * top;    //与AStack栈不同,这里,top指向栈顶元素
public:
    LStack()    //不必限定元素的最大值
    {
        listSize = 0;
        top = NULL;
    }
    ~LStack()
    {

    }

    bool push(const T &);
    bool pop(T &);
    bool topValue(T &);
    void clear();
    int length() const
    {
        return listSize;
    }
};    

template<class T> bool LStack<T>::push(const T &element)
{
    Node<T> *tmp = new Node<T>(element,top);
    top = tmp;
    ++listSize;
    return true;
}
template<class T> bool LStack<T>::pop(T &ref_elem)
{
    if (top == NULL)
    {
        return false;    //栈中没有元素
    }
    Node<T> *tmp = top;
    top = top->next;
    ref_elem = tmp->element;
    delete tmp;
    --listSize;
    return true;

}
template<class T> bool LStack<T>::topValue(T & ref_elem)
{
    if (top == NULL)
    {
        return false;    //none element in stack 
    }
    ref_elem = top->element;
    return true;
}
template<class T> void  LStack<T>::clear()
{
    Node<T> * tmp;
    while (top != NULL)
    {
        tmp = top;
        top = top->next;
        delete tmp;
    }
}
#endif

晚一些时候，我把用栈实现递归的方法，写到这里来。