用栈来表示队列，用队列来表示栈

这个问题总的栈和队列，没有自己手写，自己手写太浪费了，于是就用的java中的集合框架list下面的LinkedList

其实LinkedList既可以当做栈用，也可以当做队列来使用.

作为栈的时候，LinkedList<T> stack = new LinkedList<T>().入栈stack.push(e),出栈stack.pop()

作为队列时，LinkedList<T> queue = new LinkedList<T>()，入队queue.offer(e),出队，queue.poll()

（1）使用两个栈来实现队列先进先出的功能，思想很简单：

1）两个栈都空的时候，表示队列是空的

2）入队操作，stack1.push(e)即可

3）出队操作，首先要判断是不是空队。负责出队的是stack2，出队之前先判断stack2是不是空的，如果是空的话，先把stack1中的元素出站，并依次压入到stack2中，然后stack2弹出栈顶元素即可。

直接看代码吧：

/**
 * 使用两个 栈实现一个队列的功能 堆成的另一个问题 使用 两个队列实现一个栈
 * @author Administrator
 *
 */
public class StackQueue <T>{
    LinkedList<T> stack1;
    LinkedList<T> stack2;
    
    public StackQueue() {// 构造并初始化一个队列
        stack1 = new LinkedList<T>();
        stack2 = new LinkedList<T>();
    }
    
    /**
     * 判断队列是否为空
     * @return
     */
    public boolean isEmpty() {
        if(stack1.isEmpty() && stack2.isEmpty())
            return true;
        else return false;
    }
    
    public int getLength()
    {
        return stack1.size() + stack2.size();
    }
    
    /**
     * 入队操作
     * @param e
     */
    public void offer(T e) {
        // TODO Auto-generated method stub
        stack1.push(e);
    }
    
    /**
     * 出队操作
     * @return
     */
    public T poll()
    {
        if(stack1.isEmpty() && stack2.isEmpty())
            throw new RuntimeException(new Exception("queue is empty"));
        else
        {
            if(stack2.isEmpty())//如果stack2empty要先把stack1中的元素出站并依次压入stack2
            {
                while(stack1.isEmpty()==false)
                {
                    stack2.push(stack1.pop());
                }
            }
            return stack2.pop();
        }
    }
    
    public static void main(String[] args) {
        StackQueue<Integer> sq = new StackQueue<Integer>();
        
        System.out.println("sq is empty? :"+sq.isEmpty());
        
        sq.offer(1);
        sq.offer(2);
        sq.offer(3);
        sq.offer(4);
        sq.offer(5);
        
        System.out.println("sq.length : "+sq.getLength());
        System.out.println("sq is empty? :"+sq.isEmpty());
        
        while(!sq.isEmpty())
        {
            System.out.print(sq.poll()+",");
        }
        System.out.println();
    }
}

（2）使用两个队列实现栈的先进后出的功能

1）两个队列都空的时候表明栈空

2）始终保持queue1为空，用来入栈，如果queue1不空，的话，可以把queue1中的元素依次出队并且依次进入到queue2队中，然后返回queue2的尾元即可。这里使用java的LinkedList可以取巧，具体可以直接看下卖弄的代码：

/**
 * 使用两个队列 实现 队列的操作
 * 因为使用的是两个链队实现的 所以这个栈有空的时候，但是不需要判断满
 * @author Administrator
 *
 */
public class QueueStack <T>{
    LinkedList<T> queue1 ;
    LinkedList<T> queue2 ;
    
    public QueueStack() {    //初始化一个空队列
        queue1 = new LinkedList<T>();
        queue2 = new LinkedList<T>();
    }
    
    /**
     * 判断是不是一个空栈
     * @return
     */
    public boolean isEmpty()
    {
        if(queue1.isEmpty()&&queue2.isEmpty())
            return true;
        else
            return false;
    }
    
    /*
     * 获取栈的大小
     */
    public int getLength()
    {
        return queue1.size() + queue2.size();
    }
    
    /*
     * 入栈操作 直接让元素进第一个队
     */
    public void push(T e)
    {
        queue1.offer(e);
    }
    
    /**
     * 出站操作
     * @return
     */
    public T pop()
    {
        LinkedList<T> tmp;    //始终保持让queue1 为空 准备入栈，让queue2完成出站
        
        if(queue1.isEmpty() && queue2.isEmpty())
        {
            throw new RuntimeException(new Exception("stack is empty"));
        }
        
        if(!queue1.isEmpty()){
            tmp = queue2;
            queue2 = queue1;
            queue1 = tmp;
        }// 于是 queue1变成了 queue2,这样就可以再次入栈了，线面使用queue2实现出站
        
        /*
         * 出栈的操作就是把queue2中的 元素依次出去，最后剩一个元素 就是需要出站的元素，
         * 这里可以取巧一下直接获取 queue2.last的元素作为返回值
         */
        T e = queue2.peekLast();
        queue2.removeLast();
        return e;
    }
    
    public static void main(String[] args) {
        QueueStack<Integer> qs = new QueueStack<Integer>();
        
        System.out.println("qs is empty?:"+qs.isEmpty());
        
        System.out.println("push 1,2,3");
        
        qs.push(1);
        qs.push(2);
        qs.push(3);
        
        System.out.println("qs length :"+qs.getLength());
        System.out.println("qs is enpty:"+qs.isEmpty());
        
        System.out.print("pop one by one:");
        while(!qs.isEmpty())
        {
            System.out.print(qs.pop()+",");
        }
        System.out.println();
        
        qs.pop();
        
    }
}