0906算法题 用两个栈实现队列 包含min函数的栈

0906算法题

数据结构：堆，栈，队列，链表，树，图。
算法：动态规划，回溯法。

用两个栈实现队列

数据颠倒两次，关键什么时候颠倒。这题没有限制stack的大小，所以等输出的stack2空时颠倒最好，只需要将stack1的值复制到stack2.如果stack限制了大小，就需要在stack1满时尝试合并。

import java.util.*;
import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        stack1.push(node);
//        左边满了，要合并到右边 
    }
    
    public int pop() {
//     右边没了，要将左边合并到右边
        if(stack2.empty()){
            while(!stack1.empty())
            {
                stack2.push(stack1.pop());
            }
             return stack2.pop();
        }else{
            return stack2.pop();
        }
        
    }
}

包含min函数的栈

此栈包含的方法有：
push(value):将value压入栈中
pop():弹出栈顶元素
top():获取栈顶元素
min():获取栈中最小元素

存储minValue的结构使用栈会比较方便，应为minValue也是在同一段插入和删除的。
import java.util.*;
import java.util.Stack;

public class Solution {

    Stack<Integer> stack=new Stack<Integer>();
    private ArrayList<Integer> minList=new ArrayList();
    private int minValue;
    public void push(int node) {
        if(stack.empty())
        {
            minValue=node;
        }else{
            minValue=node<minValue?node:minValue;
        }
        minList.add(minValue);
        stack.push(node);
    }
    
    public void pop() {
        minList.remove(stack.size()-1);
        int value=stack.pop();
        minValue=minList.get(stack.size()-1);
    }
    
    public int top() {
        return stack.peek();
    }
    
    public int min() {
        return minValue;
    }
}