2021-08-06 队列 & 栈

 循环队列实现

class MyCircularQueue {
    public int[] data;
    public int q =0;
    public int h =0;

    // 构造器，设置队列长度为 k 。
    public MyCircularQueue(int k) {
        data = new int[k+1];
    }

    // 向循环队列插入一个元素。如果成功插入则返回真。
    public boolean enQueue(int value) {
        if(!this.isFull()){
            if(h == data.length -1){
                h = 0;
            }else{
                h++;
            }
            data[h] = value;
            return true;
        }
        return false;
    }
    
    // 从循环队列中删除一个元素。如果成功删除则返回真。
    public boolean deQueue() {
        if(!this.isEmpty()){
            if(q == data.length -1){
                q = 0;
            }else{
                q++;
            }
            return true;
        }
        return false;
    }
    
    // 从队首获取元素。如果队列为空，返回 -1 。
    public int Front() {
        if(!isEmpty()){
            return data[q+1];
        }
        return -1;
    }
    
    // 获取队尾元素。如果队列为空，返回 -1 。
    public int Rear() {
        if(!isEmpty()){
            return data[h];
        }
        return -1;
    }
    
    // 检查循环队列是否为空。
    public boolean isEmpty() {
        if(h == q){
            return true;
        }
        return false;
    }
    
    //检查循环队列是否已满。
    public boolean isFull() {
        if(q == (h+1)%data.length){
            return true;
        }
        return false;
    }
}

数据流中的移动平均值 - 队列实现

class MovingAverage {

    public Queue<Integer> queue1 = new LinkedList();
    public Queue<Integer> queue2 = new LinkedList();
    public int size;
    public int Ldata;
    public double sumData;
    /** Initialize your data structure here. */
    public MovingAverage(int size) {
        this.size = size;
    }
    
    public double next(int val) {
        queue1.offer(val);
        Ldata = 0;
        sumData = 0;
        while(!(queue1.peek() == null)){
            queue2.offer(queue1.peek());
            sumData += queue1.poll();
            Ldata ++;
            if(Ldata == this.size+1){
                this.Ldata--;
                sumData -= queue2.poll();
            }
        }
        while(!(queue2.peek() == null)){
            queue1.offer(queue2.poll());
        }
        return (sumData / Ldata);
        
    }
}

最小栈 - 动态数组实现

class MinStack {
    public List<Integer> Ldata;
    public int MinData;
    /** initialize your data structure here. */
    public MinStack() {
        Ldata = new ArrayList<>();
    }
    
    public void push(int val) {
        Ldata.add(val);
    }
    
    public void pop() {
        Ldata.remove(Ldata.size() -1);
    }
    
    public int top() {
        return Ldata.get(Ldata.size() -1);
    }
    
    public int getMin() {
        MinData = Ldata.get(0);
        for(int i=0;i <Ldata.size();i++){
            if(Ldata.get(i) < MinData){
                MinData = Ldata.get(i);
            }
        }
        return MinData;
    }
}