用O(1)的時間復雜度，找到棧和隊列中的最小（大）值

最近刷劍指offer，看到兩道編程題，考察在O（1）的復雜度內，找出最值。

覺得很有意思，很有借鑒意義，故記錄在此。

 

需要注意的是，這里所說的O(1) 有個前提， 就是已經通過某種容器的存儲方式進行初始化，

不然不可能在還未遍歷數據的情況下就定位出最值。

 

問題1： 重新定義棧的數據結構，實現一個能夠在O(1)時間復雜度內求出棧內最小元素的min函數。

思路： 需要一個變量minimum保存目前棧內所有值的最小值，因為最小值是隨着出棧，入棧操作變化的，所以一個變量是不夠的。

考慮引入輔助棧，輔助棧中保存於數據棧中同步的當前最小值。 即輔助棧棧頂元素為當前數據棧內的最小值。

例如：stack_data中元素為[3,4,1,2]  , 則stack_support中為[3,3,1,1]。 當數據棧2出棧，同時輔助棧1出棧， 則剩余中最小值還是輔助棧頂元素1； 數據棧再出棧1，輔助棧也出棧1， 則剩下的數據棧最小元素為輔助棧棧頂元素3.

需要重寫棧的push， pop操作。

C++代碼：  

template <typename T> class NewStack
{
    private :
    std::stack<T> stack_data;
    std::stack<T> stack_support;
    
    
    public:
    
    NewStack();
    ~NewStack();
    
    void push( T value)
    {
        stack_data.push_back(value);
        
        if (stack_support.size()==0 || stack_support.top()>value)
            stack_support.push_back(value);
        else:
            stack_support.push_back(stack_support.top());
    
    }
    
    void pop()
    {
        if (stack_data.size()>0 && stack_support.size()>0)
            {
            stack_data.pop_back();
            stack_support.pop_back();
            }
    
    }
    
    T min()
    {
        if (stack_data.size()>0 && stack_support.size()>0)
        {
            return stack_support.top();
        }
    
    
    }

 

問題2：實現在O(1)時間復雜度內，找出隊列中的最小值。

思路：前文中我們實現了棧中O(1)找最小值，因此我們只需要通過兩個棧（FILO）實現一個隊列(FIFO)，就可以實現隊列O(1)找到最小值。

即stack1的棧頂作為queue的入口，stack2的棧頂作為queue的出口。

C++代碼：兩個棧實現一個隊列如下所示：

template <typename T> class NewQueue
{
    private :
    std::stack<T> stack1;
    std::stack<T> stack2;
        
    public:
    
    NewQueue(void);
    ~NewQueue(void);
    
    
    void append(T value)
    {
        stack1.push_back(value);
    
    }
    
    T pop()
    {    
        //如果stack2為空，則從stack1拿元素中入棧到stack中
        if (stack2.size()<=0)
        {
            while(stack1.size()>0)
            {    
                T element = stack1.top(); 
                stack1.pop_back();
                stack2.push_back(element);
            
            }
        
        }
        // 如果已經沒有元素可以出棧了
        if (stack1.size()==0)
            throw new exception("queue is empty.")
            
        T res = stack2.top();
        stack2.pop_back();
        return res;
    }

}

 

如果要解決問題2, 只需結合代碼1和2，在代碼2中引入stack_support存放最小值即可：

代碼如下：

template <typename T> class NewQueue
{
    private :
    std::stack<T> stack1;
    std::stack<T> stack2;
    std::stack<T> stack_support;
    
    public:
    
    NewQueue(void);
    ~NewQueue(void);
    
    
    void append(T value)
    {
        stack1.push_back(value);
        
        if (stack_support.size()==0 || stack_support.top()>value)
             stack_support.push_back(value);
        else:
             stack_support.push_back(stack_support.top());
    
    }
    
    T pop()
    {    
        //如果stack2為空，則從stack1拿元素中入棧到stack中
        if (stack2.size()<=0)
        {
            while(stack1.size()>0)
            {    
                T element = stack1.top(); 
                stack1.pop_back();
                stack2.push_back(element);
            
            }
        
        }
        // 如果已經沒有元素可以出棧了
        if (stack2.size()==0 && stack_support.size()==0)
            throw new exception("queue is empty.")
            
        T res = stack2.top();
        stack2.pop_back();
        
        stack_support.pop_back();
        return res;
        
    T min()
    {
        if (stack2.size()>0 && stack_support.size()>0)
        {
             return stack_support.top();
        }    
    }


}