LinkedList集合之栈实现队列以及队列实现栈

利用栈来实现队列：

/**
 * 
 * 切记：LinkedList集合当做栈时只能是头进头出
 * 主要思想：需要创建两个LinkedList集合A和B
 * A用来添加元素
 * B用来备用
 * 
 * 假如栈是一个竖着的一位数组，下面的数据都是从上往下
 * 
 * 前提是用栈来实现队列
 * 栈的特点是先进后出
 * 
 * 
 * 例： 现给定一组数据——
 * 		1	2	3	4	5	6	7	8	
 * 	当给定的这一组数据添加到栈A中则是以这样的顺序出现的：
 * 		A——8	7	6	5	4	3	2	1	从上往下
 * 但是队列的特点是先进先出
 * 因此最终所要打印的结果是——1	2	3	4	5	6	7	8	从上往下
 * 		因此该问题应该怎样解决？
 * 		所以就用到了备用栈B
 * 		1、首先我先让栈A中的元素弹栈，每当弹出来的元素，我都让他先进入到栈B当中
 * 			这时栈B中的元素的顺序就为——1	2	3	4	5	6	7	8
 * 		2、再让栈B中的元素弹一个，剩下的元素再栈B中的元素弹栈，每当弹出来的元素，我都让他先进入到栈A当中
 * 			因此这个时候栈A中的元素就少了一个
 * 		重复上述操作。
 * @author dongxinxin
 *
 * @param <E>
 */

public class StackToQueue<E> {
	
	/**
	 * 创建一个集合栈来实现队列
	 */
	private LinkedList<E> stackA;
	private LinkedList<E> stackB;
	public StackToQueue() {
		stackA = new LinkedList<E>();
		stackB = new LinkedList<E>();
	}
	/**
	 * 入队
	 */
	public void offer(E e) {	
		stackA.push(e);
	}
	
	/**
	 * 出对
	 */
	public E poll() {
		while (!stackA.isEmpty()) {
			stackB.push(stackA.pop());
		}
		E ret = stackB.pop();
		
		while(!stackB.isEmpty()) {
			stackA.push(stackB.pop());
		}
		return ret;
	}
	
	/**
	 * 访问队列中的元素
	 */
	public E element() {
		while (!stackA.isEmpty()) {
			stackB.push(stackA.pop());
		}
		E ret = stackB.peek();
		
		while(!stackB.isEmpty()) {
			stackA.push(stackB.pop());
		}
		return ret;
	}
	
	/**
	 * 重写toString()方法
	 */
	@Override
	public String toString() {
		StringBuilder str = new StringBuilder();
		while(!stackA.isEmpty()){
			stackB.push(stackA.pop());
			
		}
		while(!stackB.isEmpty()){
			E e = stackB.pop();
			str.append(e);
			str.append(' ');
			stackA.push(e);
		}
		return str.toString();
	}
	
}

利用队列来实现栈：

/**
 * 切记：当LinkedList集合当做队列时，是头出尾进
 * 
 * 重要思想：需要创建两个LinkedList集合A和B
 * A是用来添加元素的
 * B是备用的
 * 
 * 由于队列时先进先出
 * 而栈是先进后出
 * 
 * 例：先给定一组数据	1	2	3	4	5	6
 * 先把这组数据添加到对列A中，则顺序为——	1	2	3	4	5	6
 * 但是最终想要打印的结果为——	6	5	4	3	2	1	(栈是先进后出)
 * 主要步骤如下：
 * 		1、先把队列A中的有效元素个数减一个元素让它一一出队列，没出一个让该元素添加到队列B中，这时
 * 			队列B中的元素的顺序为——	1	2	3	4	5
 * 		2、然后再把队列A中的最后一个元素让它出对，即可。
 * 		3、队列不需要再次返回到队列A中，因为队列是头出尾进。
 * 		4、重复上述步骤。
 * @author dongxinxin
 *
 * @param <E>
 */
public class QueueToStack<E> {
	private LinkedList<E> stackA;
	private LinkedList<E> stackB;
	public QueueToStack() {
		super();
		this.stackA = new LinkedList<E>();
		this.stackB = new LinkedList<E>();
	}
	/**
	 * 入栈
	 * 作为队列是尾进元素，头出元素
	 */
	
	public void push(E e) {
		if (stackA.isEmpty() && stackB.isEmpty()) {
			stackA.offer(e);
		} else if(stackA.isEmpty()) {
			stackB.offer(e);
		} else {
			stackA.offer(e);
		}
	}
	
	/**
	 * 弹栈
	 */
	public E pop(){
		if(!stackA.isEmpty()){
			int len = stackA.size();
			for(int i=0;i<len-1;i++){
				stackB.offer(stackA.poll());
			}
			return stackA.poll();
		}else{
			int len = stackB.size();
			for(int i=0;i<len-1;i++){
				stackA.offer(stackB.poll());
			}
			return stackB.poll();
		}
		
	}

	
	/**
	 * 访问一个元素
	 */
	public E element(){
		if(!stackA.isEmpty()){
			for(int i=0;i<stackA.size()-1;i++){
				stackB.offer(stackA.poll());
			}
			E ret = stackA.poll();
			stackB.offer(ret);
			return ret;
		}else{
			for(int i=0;i<stackB.size()-1;i++){
				stackB.offer(stackB.poll());
			}
			E ret = stackB.poll();
			stackA.offer(ret);
			return ret;
		}
	}
	/**
	 * 打印
	 */
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder();
		if (stackA.isEmpty() && stackB.isEmpty()) {
			return "";
		} else if (!stackA.isEmpty()) {
			for(int i = stackA.size() - 1; i >= 0; i--) {
				sb.append(stackA.get(i));
				sb.append(' ');
			}
		} else {
			for(int i = stackB.size() - 1; i >= 0; i--) {
				sb.append(stackB.get(i));
				sb.append(' ');
			}
		}
		return sb.toString();
	}
	
}