算法实现----栈和队列（一）

getMin栈

要求：实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中的最小元素的操作
其中pop push getMin 操作的时间复杂度为O（1）
设计的栈类型可以使用现成的栈结构
思路：两种设计思路 都是用两个栈来实现
1.当进栈的值大于栈中最小值时，minStack栈不保存；小于或等于时两个栈一起保存。
出栈时先判断出栈的值是否与最小值相等，相等则两个栈一起出栈，否则只有stack出栈。
2.进栈时的值大于栈中最小值时，stack栈进栈，minStack栈保存当前最小值；小于或等于时，两个栈一起保存；出栈时两个栈一起出栈。
详见代码：

import java.util.Stack;
public class GetMinStack {
	public static void main(String[] args) {
		MyStack stack = new MyStack();
		stack.push(9);
		stack.push(7);
		stack.push(3);
		stack.push(7);
		stack.push(3);
		stack.push(2);
		stack.push(5);
		stack.push(1);
		System.out.println(stack.getMin());
		System.out.println(stack.pop());
		System.out.println(stack.getMin());
		System.out.println(stack.pop());
		System.out.println(stack.getMin());
		System.out.println(stack.pop());
		System.out.println(stack.getMin());
	}
	
}

class MyStack{
	private Stack<Integer> stack = new Stack<>();
	private Stack<Integer> minStack = new Stack<>();
	
	public void push(int a){
		if(stack.empty()) {
			minStack.push(a);
		}else if(a > minStack.peek()){
			minStack.push(minStack.peek());
		}else {
			minStack.push(a);
		}
		stack.push(a);
	}
	
	public int pop() {
		minStack.pop();
		return stack.pop();
	}
	
	public int getMin() {
		return minStack.peek();
	}
}

使用栈实现队列

要求：用两个栈实现一个队列，支持队列的基本操作（add poll peek）

import java.util.Stack;

public class TwoStackQueue {

	public static void main(String[] args) {
		MyQueue2 mq = new MyQueue2();
		mq.add(1);
		mq.add(2);
		mq.add(3);
		System.out.println(mq.poll());
		mq.add(4);
		mq.add(5);
		System.out.println(mq.poll());
		System.out.println(mq.poll());
		System.out.println(mq.poll());
		System.out.println(mq.poll());
	}

}

// 1.poll和peek时间复杂度较高  O(2n)
class MyQueue{
	private Stack<Integer> stack1;
	private Stack<Integer> stack2;
	
	public MyQueue() {
		stack1 = new Stack<Integer>();
		stack2 = new Stack<Integer>();
	}
	
	public void add(int a ) {
		stack1.push(a);
	}
	
	public int poll() {
		if(stack1.empty()) {
			throw new RuntimeException("当前队列为空！！");
		}
		while(!stack1.empty()) {
			stack2.push(stack1.pop());
		}
		int x = stack2.pop();
		while(!stack2.empty()) {
			stack1.push(stack2.pop());
		}
		return x;
	}
	
	public int peek() {
		if(stack1.empty()) {
			throw new RuntimeException("当前队列为空！！");
		}
		while(!stack1.empty()) {
			stack2.push(stack1.pop());
		}
		int x = stack2.peek();
		while(!stack2.empty()) {
			stack1.push(stack2.pop());
		}
		return x;
	}
}

//优化
//2.
class  MyQueue2{
	private Stack<Integer> stack1;
	private Stack<Integer> stack2;
	
	public MyQueue2() {
		stack1 = new Stack<Integer>();
		stack2 = new Stack<Integer>();
	}
	
	public void stack1Tostack2() {
		if(stack2.empty()) {
			while(!stack1.empty()) {
				stack2.push(stack1.pop());
			}
		}
	}
	
	public void add(int a) {
		stack1.push(a);
		stack1Tostack2();
	}
	
	public int poll() {
		if(stack1.empty() && stack2.empty()) {
			throw new RuntimeException("此队列为空！！");
		}
		stack1Tostack2();
		return stack2.pop();
	}
	
	public int peek() {
		if(stack1.empty() && stack2.empty()) {
			throw new RuntimeException("此队列为空！！");
		}
		stack1Tostack2();
		return stack2.peek();
		
	}
}

倒置栈

要求 ：只用栈和递归实现倒置栈内元素
思路：设计两个递归函数，其中一个实现返回栈中最底层元素，
另一个则调用第一个递归将元素从最底层元素一个一个压入栈中

import java.util.Stack;

public class ReverseStack {
	
	public static void main(String[] args) {
		Stack<Integer> stack = new Stack<Integer>();
		stack.push(5);
		stack.push(4);
		stack.push(3);
		stack.push(2);
		stack.push(1);
		reverse(stack);
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());
		}
	}

	public static int getLast(Stack<Integer> stack) {
		int i = stack.pop();
		if(stack.empty()) {
			return i;
		}else {
			int last =  getLast(stack);
			stack.push(i);
			return last;
		}
	}
	
	public static void reverse(Stack<Integer> stack) {
		/*
		 * int i = getLast(stack); 
		 * if(stack.empty()) { 
		 * 		stack.push(i); 
		 * 		return; 
		 * }else {
		 * 		reverse(stack); 
		 * 		stack.push(i);
		 * }
		 */
		if(stack.empty()) {
			return;
		}
		int i = getLast(stack);
		reverse(stack);
		stack.push(i);
	}
}

猫狗队列

实现一种猫狗队列结构
要求：add方法 可以将cat和dog实例放入队列
pollAll方法 将队列中所有实例按照先进先出的顺序依次弹出
pollDog方法 将队列中的Dog实例按照先进先出的顺序依次弹出
pollCat方法 将队列中的Cat实例按照先进先出的顺序依次弹出
isEmpty方法 ，判断队列是否为空
isDogEmpty方法，判断队列中是否还有Dog实例
isCatEmpty方法 判断队列中是否还有Cat实例
思路：创建一个新类（Pet类 + 时间戳）
再创建两个队列分别放置Cat类和Dog类

import java.util.LinkedList;
import java.util.Queue;


/* 实现一种猫狗队列结构
 *      要求：add方法   可以将cat和dog实例放入队列
 *     pollAll方法  将队列中所有实例按照先进先出的顺序全部弹出
 *     pollDog方法  将队列中的Dog实例按照先进先出的顺序全部弹出
 *     pollCat方法。。
 *     isEmpty方法 ，判断队列是否为空
 *     isDogEmpty方法，判断队列中是否还有Dog实例
 *     isCatEmpty方法
 * */
public class CatAndDogQueue {

	public static void main(String[] args) {
		Cat cat1 = new Cat();
		System.out.println("cat1:"+cat1);
		Cat cat2 = new Cat();
		System.out.println("cat2:"+cat2);
		Dog dog1 = new Dog();
		System.out.println("dog1:"+dog1);
		Dog dog2 = new Dog();
		System.out.println("dog2:"+dog2);
		DogCatQueue dc = new DogCatQueue();
		dc.add(cat1);
		dc.add(dog1);
		dc.add(cat2);
		dc.add(dog2);
		System.out.println(dc.pollAll());
		System.out.println(dc.pollAll());
		System.out.println(dc.pollDog());
//		System.out.println(dc.pollDog());
//		System.out.println(dc.pollCat());
//		System.out.println(dc.pollCat());
		System.out.println(dc.isEmpty());
		System.out.println(dc.isCatEmpty());
		System.out.println(dc.isDogEmpty());
		
	}
	
	
}
	//创建两个队列，一个存储Dog，一个存储Cat
class DogCatQueue{
	private Queue<PetQueue> catQueue;
	private Queue<PetQueue> dogQueue;
	private int count;
	
	public DogCatQueue() {
		super();
		catQueue = new LinkedList<PetQueue>();
		dogQueue = new LinkedList<PetQueue>();
		count = 0;
	}
	
	public void add(Pet pet) {
		if(pet.getType().equals("Dog")){
			dogQueue.add(new PetQueue(count++, pet));
		}else {
			catQueue.add(new PetQueue(count++, pet));
		}
	}
	
	//pollAll方法  将队列中所有实例按照先进先出的顺序依此弹出
	public Pet pollAll() {
		if(catQueue.isEmpty() && dogQueue.isEmpty()) {
			throw new RuntimeException("此队列为空！！");
		}else if(!catQueue.isEmpty() && ! dogQueue.isEmpty()) {
			if(catQueue.peek().getCount() < dogQueue.peek().getCount()) {
				return catQueue.poll().getPet();
			}else {
				return dogQueue.poll().getPet();
			}
		}else if(catQueue.isEmpty()) {
			return dogQueue.poll().getPet();
		}else {
			return catQueue.poll().getPet();
		}
	}
	
	//pollDog方法  将队列中的Dog实例按照先进先出的顺序全部弹出
	public Dog pollDog() {
		if(dogQueue.isEmpty()) {
			throw new RuntimeException("此队列已空！！");
		}else {
			return (Dog)dogQueue.poll().getPet();
		}
	}
	
	//pollCat方法。。
	public Cat pollCat() {
		if(catQueue.isEmpty()) {
			throw new RuntimeException("此队列已空！！");
		}else {
			return (Cat)catQueue.poll().getPet();
		}
	}
	
	//isEmpty方法 ，判断队列是否为空
	public boolean isEmpty() {
		return catQueue.isEmpty() && dogQueue.isEmpty();
	}
	
	//isDogEmpty方法，判断队列中是否还有Dog实例
	public boolean isDogEmpty() {
		return dogQueue.isEmpty();
	}
	
	// isCatEmpty方法
	public boolean isCatEmpty() {
		return catQueue.isEmpty();
	}
	
	
}
	//宠物类
class Pet{
	private String type;
	
	
	public Pet(String type) {
		super();
		this.type = type;
	}


	public String getType() {
		return type;
	}
}

//Dog类
class Dog extends Pet{

	public Dog() {
		super("Dog");
	}
	
}

//Cat
class Cat extends Pet{
	public Cat() {
		super("Cat");
	}
}

//创建一个新类 动物+时间戳
class PetQueue{
	private int count;
	private Pet pet;
	public PetQueue() {
		super();
	}
	public PetQueue(int count, Pet pet) {
		super();
		this.count = count;
		this.pet = pet;
	}
	public int getCount() {
		return count;
	}
	public void setCount(int count) {
		this.count = count;
	}
	public Pet getPet() {
		return pet;
	}
	public void setPet(Pet pet) {
		this.pet = pet;
	}
	
}