LeetCode-255，232，622

LeetCode-255

题目描述：

解题思路：
使用两个队列实现一个栈，栈的特性先进后出，而队列先进先出。
每次入栈操作，相当于往空队列入队。每次弹栈操作将不为空的队列的size-1个元素出队并入队到空队列里面，而剩的最后一个就是需要弹栈的元素。

代码：

class MyStack {

    private Queue<Integer> qu1;
    private Queue<Integer> qu2;


    public MyStack() {
        qu1=new LinkedList<Integer>();
        qu2=new LinkedList<Integer>();
    }
    
    public void push(int x) {
            if(!qu1.isEmpty()){
                qu1.offer(x);
            }else if(!qu2.isEmpty()){
                qu2.offer(x);
            }else{
                qu1.offer(x);
            }
    }
    
    public int pop() {
            if(empty()){
                return -1;
            }
            if(!qu1.isEmpty()){
                int size=qu1.size();
                for(int i=0;i<size-1;i++){
                    qu2.offer(qu1.poll());
                }
                return qu1.poll();
            }else{
                int size=qu2.size();
                for(int i=0;i<size-1;i++){
                    qu1.offer(qu2.poll());
                }
                return qu2.poll();
            }
    }
    
    public int top() {
            if(empty()){
                return -1;
            }
            int x=-1;
            if(!qu1.isEmpty()){
                int size=qu1.size();
                for(int i=0;i<size;i++){
                   x=qu1.poll();
                   qu2.offer(x);
                }
                return x;
            }else{
                int size=qu2.size();
                for(int i=0;i<size;i++){
                    x=qu2.poll();
                    qu2.offer(x);
                }
                return x;
            }
    }
    
    public boolean empty() {
        if(qu1.isEmpty() && qu2.isEmpty()){
            return true;
        }
        return false;
    }
}

LeetCode-232

题目描述：

解题思路：
使用两个栈实现队列。
入队的元素直接放入第一个栈中。
若要出队，判断第二个栈是否为空。第二个栈为空则将第一个栈的所有元素出栈，并入栈到第二个栈中，再出栈。如果第二个栈不为空则直接出第二个栈里的元素。

代码：

class MyQueue {

   private Stack<Integer> sta1;
   private Stack<Integer> sta2;

    public MyQueue() {
        sta1=new Stack<>();
        sta2=new Stack<>();
    }
    
    public void push(int x) {
        sta1.push(x);
    }

    public int pop() {
        if(empty()){
            return -1;
        }
        if(sta2.empty()){
            while (!sta1.isEmpty()){
                Integer pop = sta1.pop();
                sta2.push(pop);
            }
        }
        return sta2.pop();
    }

    public int peek() {
        if(empty()){
            return -1;
        }
        if(sta2.empty()){
            while (!sta1.isEmpty()){
                Integer pop = sta1.pop();
                sta2.push(pop);
            }
        }
        return sta2.peek();
    }

    public boolean empty() {
        if(sta1.isEmpty()&&sta2.isEmpty()){
            return true;
        }else {
            return false;
        }
    }
}

LeetCode-622

题目描述：

解题思路：
使用数组实现循环队列，设两个标志，front头，rear尾。
计算下一个位置公式：(rear+1)%len。
当rear和front在同一个位置表示队列为空。
当rear的下一个位置时front则代表队列为满。
所有选择浪费一个位置区分队列的满或者空，则需要在初始化时，int[]的长度=（队列长度K+1）

代码：

class MyCircularQueue {

    public int front;//队头下标,当前队头
    public int rear;//队尾下标,当前存放元素的位置
    public int[] elem;

    /**
     * 构造方法
     * @param k 队列长度
     */
    public MyCircularQueue(int k) {
        this.elem=new int[k+1];
    }

    /**
     *  入队
     * @param value
     * @return
     */
    public boolean enQueue(int value) {
        if(isFull()){
            return false;
        }else {
            this.elem[this.rear]=value;
            this.rear=(rear+1)%this.elem.length;
            return true;
        }
    }

    /**
     * 出队
     * @return
     */
    public boolean deQueue() {
        if(isEmpty()){
            return false;
        }else {
            front=(this.front+1)%this.elem.length;
            return true;
        }
    }

    /**
     * 获取队头元素
     * @return
     */
    public int Front() {
        if(isEmpty()){
            return -1;
        }else {
            return this.elem[front];
        }
    }

    /**
     * 获取队尾元素
     * @return
     */
    public int Rear() {
        if(isEmpty()){
            return -1;
        }else {
            if(this.rear==0){
                return this.elem[this.elem.length-1];
            }else {
                return this.elem[this.rear-1];
            }
        }
    }

    /**
     * 是否为空
     * @return
     */
    public boolean isEmpty() {
            if(this.rear==this.front){
                return true;
            }else {
                return false;
            }
    }

    /**
     * 是否为满
     * @return
     */
    public boolean isFull() {
        if((this.rear+1)%this.elem.length==this.front){
            return true;
        }else {
            return false;
        }
    }
}