（小练习）实现一个最小栈/实现循环队列---数据结构

• 实现一个最小栈
  要求：
  设计一个支持 push ，pop ，top 操作，并能在常数时间内[O(1)]检索到最小元素的栈。
  思路：
  不能遍历，一遍历就是O(n)。利用两个栈，一个放入栈元素，另一个始终放最小元素。
  实现：

import java.util.Stack;

public class MinStack {
    public static void main(String[] args) {
        MinStack stack=new MinStack();
        stack.push(5);
        stack.push(7);
        stack.push(2);
        stack.push(3);
        stack.push(2);
        System.out.println(stack.getMin());//2
        stack.pop();
        System.out.println(stack.top());//3
    }

    Stack<Integer> stack=new Stack<>();
    Stack<Integer> minStack=new Stack<>();
    public void push(int x){
        stack.push(x);//将元素 x 推入栈中
        if (minStack.isEmpty()||x<=minStack.peek()){
            minStack.push(x);
        }
        else {
            minStack.push(minStack.peek());
        }
    }
    public void pop(){//删除栈顶的元素
        stack.pop();
        minStack.pop();
    }
    public int top(){//获取栈顶元素
        return stack.peek();
    }
    public int getMin(){//检索栈中的最小元素
        return minStack.peek();
    }
}

执行结果：

• 实现一个循环队列
  说明：
  1、设计循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
  2、循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
  要求：
  实现应该支持如下操作：
  MyCircularQueue(k): 构造器，设置队列长度为 k 。
  Front: 从队首获取元素。如果队列为空，返回 -1 。
  Rear: 获取队尾元素。如果队列为空，返回 -1 。
  enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  isEmpty(): 检查循环队列是否为空。
  isFull(): 检查循环队列是否已满。
  思路：
  用数组实现，基于下标与数组容量实现下标的循环。
  实现：

public class MyCircularQueue {
    private int[] array;//数组 保存数据
    private int frontIndex;//队首下标
    private int tailIndex;//队尾下标
    private int size;

    public static void main(String[] args) {
        MyCircularQueue CQ=new MyCircularQueue(5);
        MyCircularQueue cqNULL=new MyCircularQueue(0);
        CQ.enQueue(1);
        CQ.enQueue(2);
        CQ.enQueue(3);
        CQ.enQueue(4);
        System.out.println(CQ.enQueue(5));//true
        System.out.println(CQ.isFull());//true
        System.out.println(CQ.enQueue(6));//false

        CQ.deQueue();
        System.out.println(CQ.enQueue(6));//true

        System.out.println(CQ.Front());//2
        System.out.println(cqNULL.Front());//-1
        System.out.println(cqNULL.Rear());//-1
        System.out.println(cqNULL.isEmpty());//true
    }

    public MyCircularQueue(int k) {//k代表容量
        array=new int[k];
        frontIndex=0;
        tailIndex=0;
        size=0;
    }

    public boolean enQueue(int value) {
       if (isFull()){
           return false;//队列是满的 则插入失败
       }
       array[tailIndex]=value;//尾插
        tailIndex=(tailIndex+1)%array.length;//正常是tailIndex++ 此处取模即实现了循环
        size++;//每插入一个元素 size+1 保存对象的不可变性
        return true;
    }

    public boolean deQueue() {
        if (isEmpty()){//队列是空 则删除失败
            return false;
        }
        frontIndex=(frontIndex+1)%array.length;
        size--;
        return true;
    }

    public int Front() {
        if (isEmpty()){
            return -1;
        }
        return array[frontIndex];
    }

    public int Rear() {
        if (isEmpty()){
            return -1;
        }
        int index=(tailIndex-1+array.length)%array.length;//+ 防止tailIndex-1后为负
        return array[index];
    }

    public boolean isEmpty() {
        return size==0;
    }

    public boolean isFull() {
        return size==array.length;//容量与数据个数相等 满
    }
}

执行结果：