剑指offer——面试题30：包含min函数的栈

 #include"iostream"
 #include"stdio.h"
 using namespace std;

 const int MAXN=;
 const int INF=;

 template<typename T>class StackWithMin
 {
 public:
     void push(const T& value);
     void pop();
     T min();
 private:
     int mSize=-;
     int minNum=INF;
     T* mData=new T[MAXN];
     T* mMin=new T[MAXN];
 };

 template<typename T> void StackWithMin<T>::push(const T& value)
 {
     mData[++mSize]=value;
     if(value<minNum)
     {
         minNum=value;
     }
     mMin[mSize]=minNum;
 }

 template<typename T>void StackWithMin<T>::pop()
 {
     if(mSize<)
     {
         cout<<"stack is empty!"<<endl;
         return;
     }
     mSize--;
 }

 template<typename T>T StackWithMin<T>::min()
 {
     if(mSize<)
     {
         cout<<"stack is empty!"<<endl;
         return INF;
     }
     return mMin[mSize];
 }

 int main()
 {
     StackWithMin<double> s;
     s.push();
     cout<<s.min()<<endl;
     s.push();
     cout<<s.min()<<endl;
     s.push();
     cout<<s.min()<<endl;
     s.push();
     cout<<s.min()<<endl;
     s.pop();
     cout<<s.min()<<endl;
     s.pop();
     cout<<s.min()<<endl;
     s.pop();
     cout<<s.min()<<endl;
     s.pop();
     cout<<s.min()<<endl;
     s.pop();
     cout<<s.min()<<endl;

     return ;
 }

官方代码：

 // 面试题30：包含min函数的栈
 // 题目：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的min
 // 函数。在该栈中，调用min、push及pop的时间复杂度都是O(1)。

 #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() ==  || 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() >  && m_min.size() > );

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

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

     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.h

 // 面试题30：包含min函数的栈
 // 题目：定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的min
 // 函数。在该栈中，调用min、push及pop的时间复杂度都是O(1)。

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

 void Test(const char* testName, const StackWithMin<int>& stack, int expected)
 {
     if(testName != nullptr)
         printf("%s begins: ", testName);

     if(stack.min() == expected)
         printf("Passed.\n");
     else
         printf("Failed.\n");
 }

 int main(int argc, char* argv[])
 {
     StackWithMin<int> stack;

     stack.push();
     Test("Test1", stack, );

     stack.push();
     Test("Test2", stack, );

     stack.push();
     Test("Test3", stack, );

     stack.push();
     Test("Test4", stack, );

     stack.pop();
     Test("Test5", stack, );

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

     stack.pop();
     Test("Test7", stack, );

     stack.push();
     Test("Test8", stack, );

     return ;
 }

test.cpp

只能说官方还是厉害，早知道用栈来模拟栈。。。