栈和队列的算法题总结

1.设计一个有getMin功能的栈
实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作
要求：peek、pop、push、getMin操作的时间复杂度都是O(1)，且设计的栈类型可以使用现成的栈结构
思路：建立两个栈，一个data栈作为原始栈，一个help栈为小顶栈，跟data同步压栈，如果新进栈的数比当前help栈顶元素大，则继续压入栈顶的元素，否则压入栈顶，遍历一遍即可解决
例如：
|  4  |     |  3  |
|  6  |     |  3  |
|  3  |     |  3  |
|  5  |     |  4  |
|  4  |     |  4  |
|_5_|     |_5_|
data       help

 即，此时help栈顶即为data栈中的最小值，同步压栈

 public static class MyStack1{
 	private Stack stackData;
	private Stack stackMin;
	
	public MyStack1(){
		this.stackData = new Stack();
		this.stackMin = new Stack();
	}
	public void push(){
		if(this.stackMin.isEmpty()){
			this.stackMin.push(newNum);
		}else if(newNum <= this.getmin()){
			this.stackMin.push(newNum);
		}
		this.stackData.push(newNum);
	}
	public int pop(){
		if(this.stackData.isEmpty()){
			throw new RuntimeException("Your stack is empty!");
		}
		int value = this.stackData.pop();
		if(value == this.getmin()){
			this.stackMin.pop();
		}
		return value;
	}
	public int geimin(){
		if(this.stackMin.isEmpty()){
			throw new RuntimeException("Your stack is empty!");
		}
		return this.stackMin.peek();
	}
 }
 public static class MyStack2{
 	private Stack stackData;
	private Stack stackMin;
	
	public MyStack1(){
		this.stackData = new Stack();
		this.stackMin = new Stack();
	}
	public void push(){
		if(this.stackMin.isEmpty()){
			this.stackMin.push(newNum);
		}else if(newNum < this.getmin()){
			this.stackMin.push(newNum);
		}else{
			int newMin = this.stackMin.peek();
			this.stackMin.push(newMin);
		}
		this.stackData.push(newNum);
	}
	public int pop(){
		if(this.stackData.isEmpty()){
			throw new RuntimeException("Your stack is empty!");
		}
		this.stackMin.pop();
		return this.stackData.pop();
	}
	public int geimin(){
		if(this.stackMin.isEmpty()){
			throw new RuntimeException("Your stack is empty!");
		}
		return this.stackMin.peek();
	}
 } 

2.由两个栈组成的队列
编写一个类，用两个栈实现队列，支持队列的基本操作（add、poll、peek）
思路：一个栈正常入栈，之后倒入另一个辅助栈，辅助栈倒出即可实现。特别注意两点需要控制，倒入help辅助栈前，help必须为空，倒入help栈时，必须将data栈排空

public static class TwoStackQueue{
	public Stack stackPush;
	public Stack stackPop;
	public TwoStackQueue(){
		stackPush = new Stack();
		stackPop = new Stack();
	}
	public void add(int pushInt){
		stackPush.push(pushInt);
	}
	public int poll(){
		if(stackPop.empty() && stackPush.empty()){
			throw new RuntimeException("Queue is empty!");
		}else if(stackPop.empty()){
			while(!stackPush.empty()){
				stackPop.push(stackPush.pop());
			}
		}
		return stackPop.pop();
	}
	public int peek(){
		if(stackPop.empty() && stackPush.empty()){
			throw new RuntimeException("Queue is empty!");
		}else if(stackPop.empty()){
			while(!stackPush.empty()){
				stackPop.push(stackPush.pop());
			}
		}
		return stackPop.peek();
	}
}

3.3.由两个队列组成的栈
编写一个类，用两个队列实现栈，支持栈的基本操作（push、poll、peek）

public static class Queue{
	private LinkedList queue = new LinkedList();
	//LinkedList标准的双端队列，ArrayList是动态数组，在刷题阶段时使用链表时用LinkedList
	public boolean isEmpty(){
		return queue.isEmpty();
	}
	public int size(){
		return queue.size();
	}
	public void add(T value){
		queue.addFirst(value);
	}
	public T pull(){
		return queue.pullLast();
	}
	public T peek(){
		return queue.peek();
	}
}
public static class Stack{
	private Queue dQueue = new Queue();
	private Queue hQueue = new Queue();
	
	public boolean isEmpty(){
		return dQueue.isEmpty();
	}
	public int size(){
		return dQueue.size();
	}
	public void push(T value){
		dQueue.add(value);
	}
	public T pop(){
		if(dQueue.isEmpty()){
			throw new RuntimeException("Queue is empty!");
		}
		while(dQueue.size()!=1){
			hQueue.add(dQueue.pull());
		}
		T res = dQueue.pull();
		while(!hQueue.isEmpty()){
			dQueue.add(hQueue.pull());
		}
		return res;
	}
	public T peek(){
		if(dQueue.isEmpty()){
			throw new RuntimeException("Queue is empty!");
		}
		while(dQueue.size()!=1){
			hQueue.add(dQueue.pull());
		}
		T res = dQueue.pull();
		hQueue.add(res);
		while(!hQueue.isEmpty()){
			dQueue.add(hQueue.pull());
		}
		return res;
	}
	
}