包含min函数的栈

题目：定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。

分析:除了题目要求的栈之外新开一个栈,用来记录最小值,每当在原栈中push数据后,与最小值栈中的栈顶元素比较,如果新值较小,则在最小值栈中push新值;否则再次push栈顶元素.pop的时候,只要将最小值栈也pop一下就行了.这样,min函数只需要返回最小值栈的栈顶元素即可.

#include<stack>
#include<assert.h>
#include<stdio.h>
#include<tchar.h>

template<typename T>class  StackWithMin
{
public:
    StackWithMin(void) {}
    virtual ~StackWithMin(void) {}

    T& top(void);
    const T& top(void) const;

    void push(const T& value);
    void pop(void);

    const T& min(void) const;

    bool empty() const;
    size_t size() const;

private:
    std::stack<T> m_data;
    std::stack<T> m_min;
};

template <typename T>void StackWithMin<T>::push(const T& value)
{
    m_data.push(value);

    if(m_min.size() == 0 || value < m_min.top())
        m_min.push(value);
    else
        m_min.push(m_min.top());
}


template <typename T>void StackWithMin<T>::pop()
{
    assert(m_data.size() > 0 && m_min.size() > 0);

    m_data.pop();
    m_min.pop();
}

template<typename T>const T& StackWithMin<T>::min() const
{
    assert(m_data.size()>0 && m_min.size() >0);

    return m_min.top();
}

template<typename T>T& StackWithMin<T>::top()
{
    return m_data.top();
}
template <typename T>const T& StackWithMin<T>::top() const
{
    return m_data.top();
}

template <typename T> bool StackWithMin<T>::empty() const
{
    return m_data.empty();
}

template<typename T> size_t StackWithMin<T>::size() const
{
    return m_data.size();
}

void Test(char* testName, const StackWithMin<int>& stack, int expected)
{
    if(testName != NULL)
        printf("%s begins: \n", testName);
    if(stack.min() == expected)
        printf("Passed.\n");
    else
        printf("Failed.\n");
}

int main()
{
    StackWithMin<int> stack;
    stack.push(3);
    printf("min = %d\n", stack.min());
    stack.push(4);
    printf("min = %d\n", stack.min());
    stack.push(2);
    printf("min = %d\n", stack.min());
    stack.pop();
    printf("min = %d\n", stack.min());
    
    return 0;
}