Cracking the coding interview--Q3.5

原文：

Implement a MyQueue class which implements a queue using two stacks.

译文：

使用两个栈实现一个队列MyQueue。

队列是先进先出的数据结构(FIFO)，栈是先进后出的数据结构(FILO)， 用两个栈来实现队列的最简单方式是：进入队列则往第一个栈压栈， 出队列则将第一个栈的数据依次压入第二个栈，然后出栈。此时第二个栈顶元素即为队头元素，然后可以把队2元素再次押回栈1.

package chapter_3_StacksandQueues;

import java.util.Scanner;

class Stack_3_5 {
	private int top;
	private int size;
	private int[] data;
	
	public Stack_3_5(int size) {
		this.size = size;
		this.top = -1;
		this.data = new int[size];
	}
	
	public boolean isEmpty() {
		return top < 0;
	}
	
	public boolean isFull() {
		return top == (size-1);
	}
	
	public void push(int value) {
		if(isFull()) {
			System.out.println("Stack is full!");
			return;
		}
		data[++top] = value;
	}
	
	public void pop() {
		if(isEmpty()) {
			System.out.println("Stack is empty!");
			return;
		}
		
		top --;
	}
	
	public int top() {
		if(isEmpty()) {
			System.out.println("Stack is empty!");
			return -1;
		}
		return data[top];
	}
}

class MyQueue {
	private Stack_3_5 stack1, stack2;
	private int size;
	
	public MyQueue(int size) {
		stack1 = new Stack_3_5(size);
		stack2 = new Stack_3_5(size);
		this.size = 0;
	}
	
	// 入队，则直接在数据元素栈入栈元素即可
	public void inQueue(int value) {
		if(stack1.isFull()) {
			System.out.println("MyQueue is full!");
			return;
		}
		stack1.push(value);
		size ++;
	}
	
	// 元素出队，则需要把数据元素栈内元素依次出栈存入另一个栈内，
	// 借助另一个栈获取队头元素
	public int deQueue() {
		if(stack1.isEmpty()) {
			System.out.println("MyQueue is empty!");
			return -1;
		}
		
		while(!stack1.isEmpty()) {
			int value = stack1.top();
			stack1.pop();
			stack2.push(value);
		}
		int result = stack2.top();
		stack2.pop();
		size --;
		while(!stack2.isEmpty()) {
			int value = stack2.top();
			stack2.pop();
			stack1.push(value);
		}
		return result;
	}
}

/**
 *
 * 使用两个栈实现一个队列MyQueue
 *
 */
public class Question_3_5 {
	public static void main(String args[]) {
		Scanner scanner = new Scanner(System.in);
		int testNum = scanner.nextInt();
		scanner.nextLine();
		while(testNum -- > 0) {
			MyQueue queue = new MyQueue(5);
			
			String str = scanner.nextLine();
			String strs[] = str.split(" ");
			
			for(int i=0; i< 6; i++) {
				queue.inQueue(Integer.parseInt(strs[i]));
			}
			
			for(int i=0; i<3; i++) {
				int data = queue.deQueue();
				if(data != -1) {
					System.out.println("出队元素： " + data);
				}	
			}
			
			for(int i=6; i< strs.length; i++) {
				queue.inQueue(Integer.parseInt(strs[i]));
			}
		}
	}
}

上面的方法则每次获取队首元素都需要翻转整一个栈1，使得效率很低。

可以使用如下方法：

元素入队，则直接压入栈1，不用管栈2，如果元素出对，则首先判断栈2是否为空，如果为空，则栈1元素一次入栈压入栈2.，如果栈2不为空，则此时

获取栈2栈顶元素，因为此时栈2栈顶元素即为队首元素。这样没入入队和出对效率就增高，并且如果出对入队频繁，则队列的长度存储空间也会增加，

栈1和栈2加起来即为队列的长度，对首到中间的数据在栈2 中存储， 中间到对尾数据存储在栈1中。

package chapter_3_StacksandQueues;

import java.util.Scanner;

class MyQueue_3_5_2 {
	private Stack_3_5 stack1, stack2;
	private int size;
	
	public MyQueue_3_5_2(int size) {
		stack1 = new Stack_3_5(size);
		stack2 = new Stack_3_5(size);
		this.size = 0;
	}
	
	public boolean isEmpty() {
		return size == 0;
	}
	
	// 入队，则直接在数据元素栈入栈元素即可
	public void inQueue(int value) {
		if(stack1.isFull()) {
			System.out.println("MyQueue is full!");
			return;
		}
		stack1.push(value);
		size ++;
	}
	
	// 出栈则先获取第二个栈内数据，为空则第一个栈全部出栈并入栈第二个栈
	// 获取第二个栈顶元素，此时第二个栈顶元素就是队首元素
	public int deQueue() {
		if(size == 0) {
			System.out.println("MyQueue is empty!");
			return -1;
		}
		
		if(stack2.isEmpty()) {
			while(!stack1.isEmpty()) {
				int value = stack1.top();
				stack1.pop();
				stack2.push(value);
			}
		} 
		
		int result = stack2.top();
		stack2.pop();
		size --;
		return result;
	}
}

/**
*
* 使用两个栈实现一个队列MyQueue
*
*/
public class Question_3_5_2 {
	public static void main(String args[]) {
		Scanner scanner = new Scanner(System.in);
		int testNum = scanner.nextInt();
		scanner.nextLine();
		while(testNum -- > 0) {
			MyQueue_3_5_2 queue = new MyQueue_3_5_2(5);
			
			String str = scanner.nextLine();
			String strs[] = str.split(" ");
			
			for(int i=0; i< 6; i++) {
				queue.inQueue(Integer.parseInt(strs[i]));
			}
			
			for(int i=0; i<3; i++) {
				int data = queue.deQueue();
				if(data != -1) {
					System.out.println("出队元素： " + data);
				}	
			}
			
			for(int i=5; i< strs.length; i++) {
				queue.inQueue(Integer.parseInt(strs[i]));
			}
			
			while(!queue.isEmpty()) {
				System.out.println("出队元素： " + queue.deQueue());
			}
		}
	}
}