P132、面试题21：包含min函数的栈

实现思路：们需要一个辅助栈。每次push一个新元素的时候，同时将最小元素（或最小元素的位置。考虑到栈元素的类型可能是复杂的数据结构，用最小元素的位置将能减少空间消耗）push到辅助栈中；每次pop一个元素出栈的时候，同时pop辅助栈。

 

测试用例：
1）功能测试（输入的两个数组含有多个数字或者只有1个数字，第二个数组是或者不是第一个数组表示的压入序列对应的栈的弹出序列）；
2）特殊输入测试（输入两个null指针）

代码实现：

栈实现类：

package com.yyq;

import java.util.Comparator;
import java.util.EmptyStackException;
import java.util.Stack;

/**
 * Created by Administrator on 2015/9/16.
 */
public class StackWithMin<T extends Comparable<T>> {
    private Stack<T> m_data = new Stack<T>();       // 数据栈，存放栈的所有元素
    private Stack<T> m_min = new Stack<T>();        //辅助栈，存放栈的最小元素

    public void push(T value){
        // 把新元素添加到辅助栈
        m_data.push(value);
        // 当新元素比之前的最小元素小时，把新元素插入辅助栈里；
        // 否则把之前的最小元素重复插入辅助栈里
        if (m_min.size() == 0){
            m_min.push(value);
        }else{
            if (value.compareTo(m_min.peek()) <= 0){
                m_min.push(value);
            }else {
                m_min.push(m_min.peek());
            }
        }
    }

    public T min(){
        if (m_min.size() <= 0)
            return null;
        return m_min.peek();
    }

    public void pop(){
        if (m_data.size() > 0 && m_min.size() > 0){
            m_data.pop();
            m_min.pop();
        }else{
            throw new EmptyStackException(); // return null
        }
    }
}

实现类：

package com.yyq;

import java.util.ArrayList;

/**
 * Created by Administrator on 2015/9/16.
 */
public class MinInStack<T> {
    public static void main(String[] args) {
        System.out.println("Test1");
        StackWithMin<Integer> newStack1 = new StackWithMin<Integer>();
        newStack1.push(4);
        newStack1.push(6);
        newStack1.push(2);
        newStack1.push(5);
        newStack1.pop();
        newStack1.pop();
        newStack1.push(1);
        System.out.println(newStack1.min());

        System.out.println("Test2");
        StackWithMin<Integer> newStack2 = new StackWithMin<Integer>();
        newStack2.push(3);
        System.out.println(newStack2.min());

        System.out.println("Test3");
        StackWithMin<Integer> newStack3 = new StackWithMin<Integer>();
        System.out.println(newStack3.min());

        System.out.println("Test4");
        StackWithMin<Integer> newStack4 = new StackWithMin<Integer>();
        newStack4.push(7);
        newStack4.push(6);
        newStack4.push(5);
        System.out.println(newStack4.min());

        System.out.println("Test5");
        StackWithMin<Integer> newStack5 = new StackWithMin<Integer>();
        newStack5.push(1);
        newStack5.push(2);
        newStack5.push(3);
        System.out.println(newStack5.min());

        System.out.println("Test6");
        StackWithMin<Integer> newStack6 = new StackWithMin<Integer>();
        newStack6.push(1);
        newStack6.push(2);
        newStack6.push(3);
        newStack6.pop();
        newStack6.pop();
        newStack6.pop();
        System.out.println(newStack6.min());
    }
}

 

结果输出：

Test1

1

Test2

3

Test3

null

Test4

5

Test5

1

Test6

null