顺序栈

Stack

#include<iostream>

using namespace std;


#define INITSIZE 10         //动态数组的初始尺寸
#define INCSIZE  5          //数组满后，每次扩容所能多保存的数据元素数量

template<typename T>
class SeqStack
{
public:
    SeqStack(int length = INITSIZE);                //构造函数，参数可以是默认值
    ~SeqStack();                                    //析构函数
public:
    bool Push(const T& e);                          //入栈
    bool Pop(T& e);                                 //出栈
    bool GetTop(T& e);                              //读取栈顶元素，该元素并没有出栈

    void DispList();                                //输出顺序栈中所有元素
    int  ListLength();                              //获取顺序栈的长度

    bool IsEmpty();                                 //判断顺序栈是否为空
    bool IsFull();                                  //判断顺序栈是否已满
    void IncreaseSize();                            //当顺序栈存满数据后可以调用此函数为顺序栈扩容

private:
    T* m_data;                                      //存放顺序栈中的元素
    int m_maxsize;                                  //动态数组最大容量
    int m_top;                                      //栈顶指针，指向栈顶元素，该值为-1表示空栈
};

//通过构造函数对顺序栈进行初始化
template<typename T>
SeqStack<T>::SeqStack(int length)
{
    m_data = new T[length];     //为一维数组动态分配内存，该值和算法空间复杂度无关；
    m_maxsize = length;         //顺序栈对多可以存储m_maxsize个数据元素
    m_top = -1;                 //空栈
}

//析构函数
template<typename T>
SeqStack<T>::~SeqStack()
{
    delete [] m_data;
}

//入栈
template<typename T>
bool SeqStack<T>::Push(const T& e)
{
    if(IsFull() == true)
    {
        IncreaseSize();
    }
    m_top++;
    m_data[m_top] = e;
    return true;
}

//当顺序栈存满数据后可以调用此函数为顺序栈扩容
template<typename T>
void SeqStack<T>::IncreaseSize()
{
    T* p = m_data;
    m_data = new T[m_maxsize + INCSIZE];   //重新为数据站分配更大的内存空间
    for(int i = 0; i <= m_top; ++i)
    {
        m_data[i] = p[i];                  //将数据复制到新区域
    }
    m_maxsize = m_maxsize + INCSIZE;        //顺序栈最大长度增加INCSIZE
    delete [] p;                           //释放原来的内存空间
}

//出栈
template<typename T>
bool SeqStack<T>::Pop(T& e)
{
    if(IsEmpty() == true)
    {
        cout << "栈空，不能出栈" <<endl;
        return false;
    }
    e = m_data[m_top];              //又删除，有取到该值
    m_top--;
    return true;
}

//读取栈顶元素，但该元素并没有出栈依然在栈顶中
template<typename T>
bool SeqStack<T>::GetTop(T& e)
{
    if(IsEmpty() == true)
    {
        cout << "栈空，不能进行读取栈顶元素" <<endl;
        return false;
    }
    e = m_data[m_top];              //栈顶元素返回到e中
    return true;
}

//输出顺序栈中所有元素
template<typename T>
void SeqStack<T>::DispList()
{
    //从栈顶到栈底的顺序来显示数据
    for(int i = m_top; i >=0; --i)
    {
        cout << m_data[i] << " ";      //每个数据之间以空格分隔
    }
    cout << endl;  
}

//判断是否为空
template<typename T>
bool SeqStack<T>::IsEmpty()
{
    if(m_top == -1) 
    {
        return true;
    }
    return false;
}

//获取顺序栈的长度
template<typename T>
int SeqStack<T>::ListLength()
{
    return m_top + 1;
}

//判断是否为满
template<typename T>
bool SeqStack<T>::IsFull()
{
    if(m_top >= m_maxsize - 1)
    {
        return true;
    }
    return false;

}
int main()
{
    SeqStack<int> stack;
    stack.Push(150);
    stack.Push(200);
    stack.Push(300);
    stack.Push(400);
    stack.Push(500);

    stack.DispList();

    int temp = 0;
    stack.Pop(temp);
    stack.Pop(temp);

    cout << " ---------" <<endl;
    stack.DispList();
    return 0;
};