Java数据结构之队列与OJ题

public static void main(String[] args) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(1);
    queue.offer(2);
    queue.offer(3);
    System.out.println(queue.peek()); //获取对头元素 -> 1
    System.out.println(queue.poll()); //出队头元素 -> 1
    System.out.println(queue.peek()); //获取对头元素 -> 2
    System.out.println(queue.isEmpty()); //判断队列是否为null -> false
    queue.clear(); //清空队列
    System.out.println(queue.isEmpty()); //判断队列是否为null -> true
}

public class MyQueue { 
    private class Node { 
        private int val; //数据域 
        private Node next; //指针域名 
        private Node(int val) { 
            this.val = val; 
         } 
    } 
    //队头入，队尾出 
    private Node head; //队头引用 
    private Node last; //队尾引用 
    private int size; //队列有效数据个数
    }

// 队尾入队列
public boolean offer(int val) { 
    Node newNode = new Node(val); 
    // 如果是第一次入队列 
    if (this.head == null) { 
        this.head = newNode; 
        this.last = newNode;
    } else { 
        this.last.next = newNode; 
        this.last = this.last.next; 
    } 
    this.size++; 
    return true;
}

// 队头出队列
public int poll() { 
    Node node = this.head;
    // 如果队列为null 
    if (this.head == null) { 
        throw new MyQueueIsEmptyException("队列为空！"); 
    } else { 
        this.head = this.head.next; 
    } 
    this.size--; 
    return node.val;
}

// 取队头元素
public int peek() { 
    // 如果队列为null 
    if (this.head == null) { 
        throw new MyQueueIsEmptyException("队列为空！"); 
    } 
    else { 
        return this.head.val;
    }
}

public class MyCircularQueue {
 
    private int array[]; //存放数据的数组
    private int front; // 队头下标
    private int rear; // 队尾下标
 
    public MyCircularQueue(int k) {
        this.array = new int[k + 1]; //因为我们要浪费一个空间，所以需要多开辟一个空间
    }
 
    // 入队列
    public boolean enQueue(int value) {
        // 如果队列满的情况
        if (isFull()) {
            return false;
        }
        // 没有满就往队尾入元素
        this.array[this.rear] = value;
        // rear往前走一步，需要空出一个位置，所以当rear走到length-1时，需要修正下rear
        this.rear = (this.rear + 1) % this.array.length;
        return true;
    }
 
    // 出队列
    public boolean deQueue() {
        // 如果队列为null的情况
        if (isEmpty()) {
            return false;
        }
        // 从队头出队列，需要修正队头的位置
        this.front = (this.front + 1) % this.array.length;
        return true;
    }
    
    // 取队头元素
    public int Front() {
        // 如果队列为null的情况
        if (isEmpty()) {
            return -1;
        }
        return this.array[this.front]; //返回队头元素
    }
 
    // 取队尾元素
    public int Rear() {
        // 如果队列为null的情况
        if (isEmpty()) {
            return -1;
        }
        // 如果rear为0的情况，我们需要特殊处理
        int index = this.rear == 0 ? this.array.length - 1 : this.rear - 1;
        return this.array[index]; //返回队尾元素
    }
 
    // 判断队列是否为空
    public boolean isEmpty() {
        // 当front和rear相遇了，则表示队列中没有元素
        return this.front == this.rear;
    }
 
    // 判断队列是否满了
    public boolean isFull() {
        // 因为我们会浪费一个空间，所以rear+1等于front就满了
        // 但是我们要rear防止越界，所以要进行修正：(this.rear + 1) % this.array.length
        return (this.rear + 1) % this.array.length == this.front;
    }
}

class MyStack {
    private Queue<Integer> qu1;
    private Queue<Integer> qu2;
 
    public MyStack() {
        this.qu1 = new LinkedList<>();
        this.qu2 = new LinkedList<>();
    }
    
    public void push(int x) {
        // 两个队列都为null的情况
        if (this.qu1.isEmpty() && this.qu2.isEmpty()) {
            this.qu1.offer(x);
            return;
        }
 
        // 哪个队列不为null往哪个队列中入元素
        if (!this.qu1.isEmpty()) {
            this.qu1.offer(x);
        } else {
            this.qu2.offer(x);
        }
    }
    
    public int pop() {
        // 如果两个队列都为空的情况下，就不能出队操作
        if (empty()) {
            return -1;
        }
        // 先将不为空的队列的size-1个元素全部放到为空的队列中
        if (!this.qu1.isEmpty()) {
            while (qu1.size() - 1 != 0) {
                qu2.offer(qu1.poll());
            }
            return qu1.poll(); //返回最后一个元素
        } else {
            while (qu2.size() - 1 != 0) {
                qu1.offer(qu2.poll());
            }
            return qu2.poll(); //返回最后一个元素
        }
    }
    
    public int top() {
        // 如果队列为null
        if (empty()) {
            return -1;
        }
        int ret = 0; //保留剩余最后一个栈顶元素的变量
        // 先将不为空的队列的size-1个元素全部放到为空的队列中
        if (!this.qu1.isEmpty()) {
            while (qu1.size() - 1 != 0) {
                qu2.offer(qu1.poll());
            }
            ret = qu1.peek();
            qu2.offer(qu1.poll());
        } else {
            while (qu2.size() - 1 != 0) {
                qu1.offer(qu2.poll());
            }
            ret = qu2.peek();
            qu1.offer(qu2.poll()); //取栈顶元素不能删除掉，还得入另一个队列中去
        }
        return ret;
    }
    
    public boolean empty() {
        return this.qu1.isEmpty() && this.qu2.isEmpty(); //两个队列都为空，栈才为空
    }
}

class MyQueue {
    private Stack<Integer> pushStack;
    private Stack<Integer> popStack;
    public MyQueue() {
        this.pushStack = new Stack<>();
        this.popStack = new Stack<>();
    }
    
    public void push(int x) {
        // 入队列都在pushStack中
        this.pushStack.push(x);
    }
    
    public int pop() {
        // 出队列都从popStack出
        if (popStack.empty()) {
            // 把pushStack栈中的元素都放到popStack栈中
            while (!pushStack.empty()) {
                popStack.push(pushStack.pop());
            }
        }
        if (!popStack.empty()) {
            return popStack.pop();
        } else {
            return -1;
        }
    }
    
    public int peek() {
        // 取队头元素都从popStack中取
        if (popStack.empty()) {
            // 把pushStack栈中的元素都放到popStack栈中
            while (!pushStack.empty()) {
                popStack.push(pushStack.pop());
            }
        }
        if (!popStack.empty()) {
            return popStack.peek();
        } else {
            return -1;
        }
    }
    
    public boolean empty() {
        return pushStack.empty() && popStack.empty();
    }
}

public class MinStack {
    private Stack<Integer> stack;
    private Stack<Integer> minStack;
    public MinStack() {
        this.stack = new Stack<>();
        this.minStack = new Stack<>();
    }
    
    public void push(int val) {
        // 如果stack为null，表示第一次入栈，
        // 此时入栈的元素也是此时栈中最小值，也要入minStack栈
        if (this.stack.isEmpty()) {
            this.stack.push(val);
            this.minStack.push(val);
            return;
        }
        this.stack.push(val);
        // 如果stack栈顶元素小于等于minStack栈顶元素，则也需要入minStack栈中
        if (this.stack.peek() <= this.minStack.peek()) {
            this.minStack.push(val);
        }
    }
 
    // 出栈
    public void pop() {
        if (this.stack.isEmpty()) {
            return;
        }
        // 如果出栈元素与minStack元素相等，minStack也要出栈
        if (this.stack.pop().equals(this.minStack.peek())) {
            this.minStack.pop();
        }
    }
 
    // 取栈顶元素
    public int top() {
        if (this.stack.isEmpty()) {
            return -1;
        } else {
            return this.stack.peek();
        }
    }
 
    // 取栈中最小元素
    public int getMin() {
        if (this.stack.isEmpty()) {
            return -1;
        } else {
            return this.minStack.peek();
        }
    }
}