各种实现队列的问题:链表实现，栈实现队列及队列实现栈

链表实现一个队列的功能

//链表节点类
class QueueNode{
	Object data;
	QueueNode next;
	
	public QueueNode(Object data){
		this.data=data;
	}
	public QueueNode(Object data,QueueNode next){
		this.data=data;
		this.next=next;
	}
	
}
//单向链表实现队列
public class QueueLink {
	//定义队首队尾指针
	QueueNode front;
	QueueNode rear;
	
	public QueueLink(){
		this.front=null;
		this.rear=null;
	}
	
	//将一个对象追加到队列的尾部
	public void enQueue(Object obj){
		if(rear==null&&front==null){
			rear=new QueueNode(obj);
			front=rear;
		}else{
			QueueNode node=new QueueNode(obj);
			rear.next=node;
			rear=rear.next;
		}
	}
	
	//队首对象出队
	public Object deQueue(){
		//队列空
		if(front==null){
			return null;
		}//队列只有一个对象
		if(front==rear&&rear!=null){
			QueueNode node=front;
			rear=null;
			front=null;
			return node.data;
		}
		//普遍多值时的队列
			QueueNode node=front;
			front=front.next;
			return node.data;
	}
	public static void main(String[] args){
		QueueLink q=new QueueLink();
		q.enQueue("aaa");
		q.enQueue("bbb");
		q.enQueue("ccc");
		q.enQueue("ddd");
		q.enQueue("fff");
		for(int i=0;i<4;i++){
			System.out.println(q.deQueue());
		}
	}
	
}

两个栈实现一个队列，看似简单实则有些坑啊……

import java.util.Stack;

public class StackQueue {
	Stack<String> stackA=new Stack<String>();
	Stack<String> stackB=new Stack<String>();
	public void enQueue(String str){
		if(stackB.isEmpty()){
			stackA.push(str);
		}if(!stackB.isEmpty()){
			while(!stackB.isEmpty()){
				stackA.push(stackB.pop());
				
			}stackA.push(str);
		}
	}
	
	public String pull(){
		//以下是从错到对的思维过程：
		//自己的写法，但每次pull本身是一位操作，不需要处理两个栈的问题，
		//如果两个栈都有内容，只需先把b栈的出光，把a的全数push进来即可
		//push一位不可，达不到出栈要求
		//if，else判断b栈是否为空即可
		//但其实b栈在只有入队时应该可保证无内容
		//但一旦入栈出栈交叉操作，会存在ab都有内容的情况
		//但貌似入栈后b就肯定为空了
		//出栈操作a肯定为空
		//结论就是这题好多坑
//		if(stackB.isEmpty()&&!stackA.isEmpty()){
//			stackB.push(stackA.pop());
//			return stackB.pop();
//		}
//		//可能（肯定）不会出现
//		if(!stackB.isEmpty()&&!stackA.isEmpty()){
//		}
//		if(stackA.isEmpty()&&!stackB.isEmpty()){
//			return stackB.pop();
//		}else{
//			return null;
//		}
			
		if(!stackB.isEmpty()){
			return stackB.pop();
		}else{
			while(!stackA.isEmpty()){
				stackB.push(stackA.pop());
			}
			return stackB.pop();
		}
	}
	
	public boolean queEmpty(){
		if(stackA.isEmpty()&&stackB.isEmpty()){
			return true;
		}else return false;
	}
	public static void main(String args[]){
		
		StackQueue q=new StackQueue();
		q.enQueue("aaa");
		q.enQueue("bbb");
		q.enQueue("ccc");
		System.out.println(q.pull());
		q.enQueue("ddd");
		while(!q.queEmpty())
			System.out.println(q.pull());
		}
	}

两个队列实现一个栈。不停导队列即可 出去一个导一次

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


public class QueueStack {
	Queue<String> queueA=new LinkedList<String>();
	Queue<String> queueB=new LinkedList<String>();
	
	public void push(String str){
		if(queueB.isEmpty()){
			queueA.offer(str);
		}else if(queueA.isEmpty()){
			queueB.offer(str);
		}
		
	}
	public String pop(){
		if(queueB.isEmpty()){
			while(queueA.size()>1){
				queueB.offer(queueA.poll());
			}
			return queueA.poll();
		}
		else if(queueA.isEmpty()){
			while(queueB.size()>1){
				queueA.offer(queueB.poll());
			}
			return queueB.poll();
		}
		return null;
	}
	
	
	public boolean empty(){
		if (queueB.isEmpty()&&queueA.isEmpty()){
			return true;
		}else return false;
	}
	public static void main(String args[]){
		QueueStack q=new QueueStack();
		q.push("aaa");
		q.push("bbb");
		q.push("ccc");
		q.push("ddd");
		System.out.println(q.pop());
		q.push("eee");
		while(!q.empty()){
			System.out.println(q.pop());
		}
	}
}