栈的顺序存储和链式存储实现

题目：分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。

#include <iostream>
using namespace std;

//顺序栈
template <typename T>
class SeqStack
{
public:
    SeqStack(int MaxSize);
    ~SeqStack();

    void push(const T &x);
    T getTop();
    T pop();
    bool isFull();
    bool isEmpty();
    int getSize();
    int getMaxSize();
    friend ostream &operator<<(ostream &os, const SeqStack<T> &S);

private:
    T *_elements;
    int _top;
    int _maxSize;
    void overflowProcess();
};

template <typename T>
SeqStack<T>::SeqStack(int MaxSize)
{
    _maxSize = MaxSize;
    _elements = new T[_maxSize];
    if (_elements == NULL)
    {
        cerr << "内存分配错误！" << endl;
        exit(1);
    }
    _top = 0;
}

template <typename T>
SeqStack<T>::~SeqStack()
{
    delete[] _elements;
}

template <typename T>
int SeqStack<T>::getSize()
{
    return _top;
}

template <typename T>
int SeqStack<T>::getMaxSize()
{
    return _maxSize;
}

template <typename T>
bool SeqStack<T>::isEmpty()
{
    if (_top == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template <typename T>
bool SeqStack<T>::isFull()
{
    if (_top == _maxSize)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template <typename T>
T SeqStack<T>::getTop()
{
    if (isEmpty())
    {
        cerr << "栈为空" << endl;
        return NULL;
    }
    else
    {
        return _elements[_top - 1];
    }
}

template <typename T>
void SeqStack<T>::push(const T &x)
{
    if (isFull())
    {
        overflowProcess();
    }
    _elements[_top++] = x;
}

template <typename T>
T SeqStack<T>::pop()
{
    if (isEmpty())
    {
        cerr << "栈为空" << endl;
        return NULL;
    }
    else
    {
        T temp = _elements[_top - 1];
        _elements[_top--] = NULL;
        return temp;
    }
}

template <typename T>
void SeqStack<T>::overflowProcess()
{
    T *newelements = new T[_maxSize * 2];
    if (newelements == NULL)
    {
        cerr << "内存分配错误！" << endl;
        exit(1);
    }
    for (int i = 0; i < _top; i++)
    {
        newelements[i] = _elements[i];
    }
    _maxSize = _maxSize * 2;
    delete[] _elements;
    _elements = newelements;
}

template <typename T>
ostream &operator<<(ostream &os, const SeqStack<T> &S)
{
    os << "栈内存为：" << S.getMaxSize() << "/t";
    os << "共有元素：" << S.getSize() << "/t";
    os << "栈顶是：" << S.getTop() << "/t";
    for (int i = 1; i <= S.getSize(); i++)
    {
        os << "第" << i << "个元素为：" << S._elements[i - 1] << "/t";
    }
    return os;
}

int main()
{
    int select;
    SeqStack<int> intStack(20);
    // LinkStack<int> intStack;
    cout << "1."<< "查询栈是否为空" << endl;
    cout << "2."<< "查询栈是否为满" << endl;
    cout << "3."<< "查询栈当前长度" << endl;
    cout << "4."<< "查询栈最大容量" << endl;
    cout << "5."<< "查询栈目前栈顶" << endl;
    cout << "6."<< "入栈" << endl;
    cout << "7."<< "出栈" << endl;
    cout << "8."<< "退出" << endl;

    while (true)
    {
        cout << "请选择操作：";
        cin >> select;
        switch (select)
        {
        case 1:
            if (intStack.isEmpty())
            {
                cout << "栈为空" << endl;
            }
            else
            {
                cout << "栈不空" << endl;
            }
            break;
        case 2:
            if (intStack.isFull()) // intStack.isFull()
            {
                cout << "栈为满" << endl;
            }
            else
            {
                cout << "栈不满" << endl;
            }
            break;
        case 3:
            cout << "栈的长度为：" << intStack.getSize() << endl;
            break;
        case 4:
            cout << "栈的最大长度为：" << intStack.getMaxSize() << endl;
            break;
        case 5:
            cout << "栈顶元素为：" << intStack.getTop() << endl;
            break;
        case 6:
            int x;
            cout << "请输入要入栈的元素：";
            cin >> x;
            intStack.push(x);
            break;
        case 7:
            cout << "出栈元素为：" << intStack.pop() << endl;
            break;
        default:
            exit(0);
            break;
        }
    }
    return 0;
}

链式栈

//链式栈

#define Posi(T) ListNode<T> *

template <typename T>
struct ListNode
{
    T date;       //数值
    Posi(T) link; //后继指针

    //默认构造器
    ListNode(T item, Posi(T) ptr = NULL)
    {
        date = item;
        link = ptr;
    }
    ListNode(Posi(T) ptr = NULL)
    {
        link = ptr;
    };
};

template <typename T>
class LinkStack
{
public:
    LinkStack();
    ~LinkStack();

    void makeEmpty();
    void push(const T &x);
    T getTop();
    T pop();
    bool isEmpty();
    int getSize();
    Posi(T) getTopPointer();
    friend ostream &operator<<(ostream &os, LinkStack<T> &S);

private:
    Posi(T) top;
    int size;
};

template <typename T>
Posi(T) LinkStack<T>::getTopPointer()
{
    return top;
}

template <typename T>
LinkStack<T>::LinkStack()
{
    top = NULL;
    size = 0;
}

template <typename T>
LinkStack<T>::~LinkStack()
{
    makeEmpty();
}

template <typename T>
void LinkStack<T>::push(const T &x)
{
    top = new ListNode<T>(x, top);
    if (top == NULL)
    {
        cerr << "内存分配错误！" << endl;
        exit(1);
    }
    size++;
}

template <typename T>
bool LinkStack<T>::isEmpty()
{
    if (top == NULL)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template <typename T>
int LinkStack<T>::getSize()
{
    return size;
}

template <typename T>
T LinkStack<T>::getTop()
{
    if (isEmpty())
    {
        cerr << "栈为空" << endl;
        return NULL;
    }
    else
    {
        return top->date;
    }
}

template <typename T>
T LinkStack<T>::pop()
{
    if (isEmpty())
    {
        cerr << "栈为空" << endl;
        return NULL;
    }
    else
    {
        T x = top->date;
        Posi(T) p = top;
        top = top->link;
        delete p;
        return x;
        size--;
    }
}

template <typename T>
void LinkStack<T>::makeEmpty()
{
    Posi(T) p;
    while (top != NULL)
    {
        p = top;
        top = top->link;
        delete p;
    }
}

template <typename T>
ostream &operator<<(ostream &os, LinkStack<T> &L)
{
    os << "共有元素：" << L.getSize() << endl;
    os << "栈顶是：" << L.getTop() << endl;
    for (int i = L.getSize(); i > 0; i++)
    {
        Posi(T) p = L.getTopPointer();
        os << "第" << i << "个元素为：" << p->date << endl;
        p = p->link;
    }
    return os;
}

int main()
{
    int select;
    LinkStack<int> intStack;
    cout << "1."<< "查询栈是否为空" << endl;
    cout << "2."<< "查询栈当前长度" << endl;
    cout << "3."<< "查询栈最大容量" << endl;
    cout << "4."<< "查询栈目前栈顶" << endl;
    cout << "5."<< "入栈" << endl;
    cout << "6."<< "出栈" << endl;
    cout << "7."<< "退出" << endl;

    while (true)
    {
        cout << "请选择操作：";
        cin >> select;
        switch (select)
        {
        case 1:
            if (intStack.isEmpty())
            {
                cout << "栈为空" << endl;
            }
            else
            {
                cout << "栈不空" << endl;
            }
            break;
        case 2:
            cout << "栈的长度为：" << intStack.getSize() << endl;
            break;
        case 3:
            cout << "栈的最大长度为：" << intStack.getMaxSize() << endl;
            break;
        case 4:
            cout << "栈顶元素为：" << intStack.getTop() << endl;
            break;
        case 5:
            int x;
            cout << "请输入要入栈的元素：";
            cin >> x;
            intStack.push(x);
            break;
        case 6:
            cout << "出栈元素为：" << intStack.pop() << endl;
            break;
        default:
            exit(0);
            break;
        }
    }
    return 0;
}