1.通过两个栈来实现一个队列

import java.util.Stack;

/**
 * 通过两个栈来实现一个队列
 */
public class QueueWithStack {
    private Stack stack1=new Stack();
    private Stack stack2=new Stack();

    public void  add(Object obj)
    {
        stack1.push(obj);
    }

    public Object pop()
    {
        if (!stack2.isEmpty())
        {
            return stack2.pop();
        }
        if (stack1.isEmpty())
        {
            throw new RuntimeException("队列为空");
        }
        while (!stack1.isEmpty())
        {
            stack2.push(stack1.pop());
        }
        return stack2.pop();
    }

}

2.设计含有最小函数min()的栈，要求min,push,pop，的时间复杂度都为o(1),min方法的作用是返回栈中的最小值

import java.util.Stack;
/**
 * 设计含有最小函数min()的栈，要求min,push,pop，的时间复杂度都为o(1)
 * min方法的作用是返回栈中的最小值
 */
public class MinStack
{
    private Stack<Integer> stack1=new Stack<Integer>();
    private Stack<Integer> minStak=new Stack<Integer>();
    /**
     * 添加数据，首先是往Stac栈中添加
     * 如果最小栈minStack为空，或者栈顶的元素比新添加的元素要大，则将新元素也添加到最小栈中
     * @param value
     */
    public void push(int value)
    {
        stack1.push(value);
        if (minStak.isEmpty()||(minStak.peek()>value))
        {
            minStak.push(value);
        }
    }
    /**
     * 如果Stack为空，直接返回
     * 如果Stack不为空，得到栈顶元素，同时将栈顶元素弹出
     * 如果最小的栈顶元素与Stack弹出的元素相等，那么最小栈也要弹出
     */
    public void pop()
    {
        if (stack1.isEmpty())
        {
            return ;
        }
        Integer peek = stack1.peek();
        stack1.pop();
        if (minStak.peek()==peek)
        {
            minStak.pop();
        }
    }
    /**
     * 查找栈的最小元素
     * @return
     */
    public int min()
    {
        return minStak.pop();
    }
}