栈的压入，栈的弹出，最小栈，用队列实现栈，设计循环队列

 

栈的压入，栈的弹出 

 

输入两个整数序列，第一个序列表示栈的压入序列，判断第二个序列是否可能是该栈的弹出序列，假设压入栈中的所有数字均不相等，如pushA:1，2，3，4，5是某栈的压入序列，序列popA:4，5，3，2，1是该栈序列对应的一个弹出的一个弹出序列。

结论：栈为空的时候，说明是可能的出栈序列。

1.神魔时候入栈？

每次都入栈

2.神魔时候出栈？

栈不为空并且栈顶元素和k下标相等的时候可以出栈

3.定义i，j,都遍历完说明就是了

    public static boolean IsPopOrder(int[] pushA,int[] popA){
        Stack<Integer> stack=new Stack<>();
        int j=0;

        for (int i = 0; i < pushA.length; i++) {
            stack.push(pushA[i]);
            while(!stack.isEmpty()&&stack.peek()==popA[j]&&j<popA.length) {
                stack.pop();
                j++;
            }
            //在while里面判断的时候，stac弹出的已经是引用类型，这里就发生了自动拆箱
            //但是在牛客网中提交并没有问题
        }
        return stack.isEmpty();

    }

 

最小栈

/****给定stack，和minStack
 * 1.当栈中第一次存放数据时，两个栈中都要存放元素
 * 2.从第二次开始，每次入栈，都要和栈顶元素进行比较，小于的话就入栈
 * 此操作保证了minStack中的栈顶元素时当时的较小值；
 * 3.出栈：每次出栈都要和栈顶元素进行比较，如果和栈顶元素一样，那麽就要两个栈都得出
 *
 * **/

import java.util.Stack;

class MinStack {
    private Stack<Integer> stack ;
    private Stack<Integer> minStack ;
    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }
    
    public void push(int val) {
        stack.push(val);
        //第一次在最小栈当中存储元素
        if(minStack.empty()) {
            minStack.push(val);
        }else {
            if(val <= minStack.peek()) {
                minStack.push(val);
            }
        }
    }
    
    public void pop() {
        //栈为空 则不能进行弹出元素
        if(stack.empty()) {
            return;
        }
        int val = stack.pop();
        if(val == minStack.peek()) {
            minStack.pop();
        }
    }
    //获取栈顶元素 和 最小栈没有关系
    public int top() {
        if(stack.empty()) {
            return -1;
        }
        return stack.peek();
    }

    //获取元素 不是删除元素
    public int getMin() {
        return minStack.peek();
    }
    public static void main(String[] args) {
        MinStack minStack1 = new MinStack();
        minStack1.push(-2);
        minStack1.push(0);
        minStack1.push(1);
        int x1 = minStack1.getMin();
        int x2 = minStack1.top();
        minStack1.pop();
        int x4 = minStack1.getMin();
    }
}

 

用队列实现栈

//栈：push,pop,peek;

//队列：offer,poll,peek

你觉得一个普通的队列能实现这个栈嘛？必然不能！

弄两个队列

1.push元素应该怎末放？

//放入不为空的队列

2.出栈？

将不为空的队列中的n-1个到另一个队列中。剩下的就是要出栈的元素

 

 

class MyStack {
    public Queue<Integer> qu1;
    public Queue<Integer> qu2;
    public MyStack() {
        qu1=new LinkedList<>();
        qu2=new LinkedList<>();
    }
    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 currentSize=qu1.size();
            //注意：你的这个不能写死，如果全写在for中是不可以的，因为你的队列每弹出一个元素，大小都在变化
            for(int i=0;i<currentSize-1;i++){
                int x=qu1.poll();
                qu2.offer(x);
            }
            return qu1.poll();
        }
          if(!qu2.isEmpty()){
            int currentSize=qu2.size();
            for(int i=0;i<currentSize-1;i++){
                int x=qu2.poll();
                qu2.offer(x);
            }
            return qu2.poll();
        }
        return -1;
    }
    //peek（）方法
    public int top() {
//最后一个在x中存放的就是top元素
          if(empty()){
            return -1;
        }
        //出不为空的队列
        if(!qu1.isEmpty()){
            //易错
            int currentSize=qu1.size();
            //注意：你的这个不能写死，如果全写在for中是不可以的，因为你的队列每弹出一个元素，大小都在变化
            int x=-1;
            for(int i=0;i<currentSize;i++){
                x=qu1.poll();
                qu2.offer(x);
            }
            return x;
        }
          if(!qu2.isEmpty()){
            int currentSize=qu2.size();
            int x=-1;
            for(int i=0;i<currentSize;i++){
                x=qu2.poll();
                qu2.offer(x);
            }
            return x;
        }
        return -1;
    }
    
    public boolean empty() {
        return qu1.isEmpty()&&qu2.isEmpty();
    }
}

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

 设计循环队列

以浪费一个空间判断

class MyCircularQueue {
    private int[] elem;
    private int front;//队头下标
    private int rear;//队尾下标

    public MyCircularQueue(int k) {
        this.elem = new int[k+1];
    }

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

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

    //得到队头元素
    public int Front() {
        if(isEmpty()) {
            return -1;
        }
        return elem[front];
    }
    //得到队尾元素
    public int Rear() {
        if(isEmpty()) {
            return -1;
        }
        int index = (rear == 0) ? elem.length-1 : rear-1;
        return elem[index];
    }
    
    public boolean isEmpty() {
        return rear == front;
    }
    
    public boolean isFull() {
        return (rear+1) % elem.length == front;
    }


    // public static void main(String[] args) {
    //     MyCircularQueue myCircularQueue = new MyCircularQueue(3);
    //     System.out.println(myCircularQueue.enQueue(1));
    //     System.out.println(myCircularQueue.enQueue(2));
    //     System.out.println(myCircularQueue.enQueue(3));
    //     System.out.println(myCircularQueue.enQueue(4));
    //     System.out.println(myCircularQueue.Rear());//  2
    //     System.out.println(myCircularQueue.isFull());
    //     System.out.println(myCircularQueue.deQueue());
    //     System.out.println(myCircularQueue.enQueue(4));
    //     System.out.println(myCircularQueue.Rear());
    // }
}