包含max 函数的栈

#include <iostream>
using namespace std;

const int MAXN = 100;
template<typename Type>
class Stack {
public:
    Stack() {
        stackTop = -1;
        maxStackItemIndex = -1;
    }
    bool empty();
    void push(Type x);
    void pop();
    Type max();
private:
    Type stackItem[MAXN];
    int stackTop;
    int link2NextMaxItem[MAXN];
    int maxStackItemIndex;

};

template<typename Type>
void Stack<Type>::push(Type x) {
    if (stackTop == MAXN - 1) {
        cout << "stack is full!" << endl;
    }
    ++stackTop;
    if (maxStackItemIndex == -1) {
        maxStackItemIndex = 0;
    } else {
        if (x > stackItem[maxStackItemIndex]) {
            link2NextMaxItem[stackTop] = maxStackItemIndex;
            maxStackItemIndex = stackTop;
        }
    }
    stackItem[stackTop] = x;
}

template<typename Type> 
bool Stack<Type>::empty() {
    return stackTop == -1;
}

template<typename Type>
void Stack<Type>::pop() {
    if (empty()) {
        cout << "Stack is empty!" << endl;
    }

    if (maxStackItemIndex == stackTop) {
        maxStackItemIndex = link2NextMaxItem[maxStackItemIndex];
    }
    --stackTop;
    //cout << maxStackItemIndex << endl;
}

template<typename Type>
Type Stack<Type>::max() {
    if (empty()) {
        cout << "stack is empty!" << endl;
        return -1;
    }


    return stackItem[maxStackItemIndex];
}

int main() {
    Stack<int> s;
    for (int i = 0; i < 10; ++i) {
        s.push(i);
    }
    for (int i = 0; i < 10; ++i) {
        s.pop();
        cout << s.max() << endl;
    }
}

#include <iostream>
#include <stack>
using namespace std;

template<typename T> 
class Stack {
public:
    void push(const T& value);
    void pop();
    T max();
private:
    stack<T>m_data;
    stack<T>m_max;
};

template <typename T>
void Stack<T>::push(const T& value) {
    if (m_max.empty() || value > m_max.top()) {
        m_max.push(value);
    }
    else {
        m_max.push(m_max.top());
    }
    m_data.push(value);
}

template<typename T>
void Stack<T>::pop() {
    if (m_max.empty() || m_data.empty()) {
        cout << "stack is empty!" << endl;
    }
    m_max.pop();
    m_data.pop();
}

template<typename T>
T Stack<T>::max() {
    if (m_max.empty()) {
        cout << "stack is empty!" << endl;
        return INT_MIN;
    }
    return m_max.top();
}

int main() {
    Stack<int> s;
    for (int i = 0; i < 10; ++i) {
        s.push(i);
    }

    for (int i = 0; i < 10; ++i) {
        s.pop();
        cout << s.max() << endl;
    }
}