两个栈（队列）模拟一个队列（栈）

一、两个栈模拟一个队列

思路

简要：给出数组arr[ ]={1,2,3,4,5}，通过两个栈实现一个队列的功能，输出1,2,3,4,5.

1. 定义两个栈，并给出数组arr
   
2. 将arr依次入栈至stack1
   
3. 获取 stack1 的栈顶元素入栈至 stack2 ，stack1依次出栈
4. stack2 出栈并打印
   

代码

//   两堆栈模拟队列

import java.util.Stack;

public class MyStack<T> {
    public static<T> void twoStackToOneQueue(T[] arr){
        Stack<T> st1 = new Stack<>();
        Stack<T> st2 = new Stack<>();
        //将数组全部入到第一个栈
        for (int i=0;i<arr.length;i++){
            st1.push(arr[i]);
        }
        //st1出栈至st2
       while(!st1.isEmpty()){
            st2.push(st1.peek());
            st1.pop();
       }
       //打印st2
       while(!st2.isEmpty()){
            System.out.print(st2.peek()+" ");
            st2.pop();
       }
    }
    public static void main (String[] args){

        twoStackToOneQueue(new Integer[]{1,2,3,4,5});
    }

}

二、两个队列模拟一个栈

思路

简要：给出数组arr[ ]={1,2,3,4,5}，通过两个队列实现一个栈的功能，输出5,4,3,2,1.

1. 定义两个队列，并将数组arr入列
   
2. queue1 依次入列至 queue2，直至剩余最后一个元素，并将其出列打印
   
3. 重复上步，至队列为空
   
4. 转换完成
   

代码

    两队列模拟堆栈

import java.util.Arrays;
import java.util.EmptyStackException;

public class MyQueue<T> {
/TODO: 定义队列
    private T[] element;
    private int size;
    private static final int INITSIZE = 10;
    public MyQueue(){
        element = (T[])new Object[INITSIZE];
    }
    public void push(T value){
        if(size == element.length){
            element = Arrays.copyOf(element,element.length*2);
        }
        element[size++] = value;
    }

    public int getSize() {
        return size;
    }

    //获取队头元素
    public T peek(){
        if(size == 0){
            throw new EmptyStackException();
        }
        return element[0];
    }
    public void pop(){
        if(size == 0){//isEmpty()
            return;
        }
        for(int i=1;i<size;i++){
            element[i-1] = element[i];
        }
        element[size-1] = null;//防止内存泄漏
        size--;
    }



/TODO: 方法实现
    public static <T> void twoQueueToStack(T[] arr){
        MyQueue<T> queue1 = new MyQueue<>();
        MyQueue<T> queue2 = new MyQueue<>();
        //入队列
        for (int i=0;i<arr.length;i++){
            queue1.push(arr[i]);
        }
        //大循环
        int srcLength = arr.length;
        while (srcLength>0) {
            //出队列1，至余最后一位
            while (queue1.getSize() > 1) {
                queue2.push(queue1.peek());
                queue1.pop();
            }
            //将剩余的一个元素出队打印
            System.out.print(queue1.peek() + " ");
            queue1.pop();
            srcLength--;

            //出队列2，至余最后一位
            if (srcLength != 0) {  //上一轮(出队列1)结束后，判断srcLenght 是否为零
                while (queue2.getSize() > 1) {
                    queue1.push(queue2.peek());
                    queue2.pop();
                }
                //将剩余的一个元素出队打印
                System.out.print(queue2.peek() + " ");
                queue2.pop();
                srcLength--;
            }
        }
    }

    public static void main (String[] args){
        twoQueueToStack(new Integer[]{1,2,3,4,5});
    }
}