得到栈的最小元素

如题: 定义栈的数据结构,请在该类型中实现一个能够得到栈的最小元素min函数.在该栈中,调用min/push/以及pop的时间复杂度都是O(1).
在栈中输出最小元素
1. 用一个栈 做辅助存放最小元素,.通过弹出得到最小元素
2. 栈1加入一个数.在栈2中加入当前1中最小值
如: 入栈1中 3 ,当前最小值为3 在辅助栈中加入3
当栈1 push 4时.在辅助栈中加入最小元素 3
当栈1 push 2时.在辅助栈中加入最小元素 2
当栈1 push 1时,在辅助栈中加入最小元素 1
栈 1: 3 4 2 1 栈2: 3 3 2 1
当出栈的时候: 栈1弹出1, 辅助栈弹出 1最小 获取最小元素

//栈1 与 辅助 栈2 保持size大小一致

MinInStack.cpp文件 : 定义控制台应用程序的入口点。

#include "StackWithMin.h"
#include <stdlib.h>

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 _tmain(int argc, _TCHAR* argv[])
{
    StackWithMin<int> stack;
    stack.push(3);
    Test("Test1", stack, 3);

    stack.push(4);
    Test("test2", stack, 3);

    stack.push(2);
    Test("test3", stack, 2);

    stack.push(3);
    Test("test4", stack, 2);

    stack.pop();
    Test("test5", stack, 2);

    stack.pop();
    Test("Test6", stack, 3);

    stack.push(0);
    Test("test7", stack, 0);

    system("pause");
    return 0;
}

StackWithMin.h文件

#pragma once

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

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

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

    const T& min() 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())//如果push的值比min中的top值小,就加入值
    {
        m_min.push(value);
    }
    else
        m_min.push(m_min.top());  //如果新加入的值,没有min栈中最小的值作为 min栈中最上面的
}

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();
}

StackWithMin.cpp文件

#include "StackWithMin.h"