栈和队列的代码实现

栈

概念：
栈是一种特殊的线性表，只允许在固定的一段进行插入删除操作，进行数据的插入删除操作的一端称为栈顶，另一端称为栈底，栈中的元素遵循先进后出的原则。
压栈：
栈的插入操作叫做压栈，入数据在栈顶
栈的删除操作叫做出栈，出数据也在栈顶

用顺序表实现栈的相关操作：

public class MyStack {
    private int[] arr = new int[100];
    private int size;

    public boolean push(int x) {
        if(size == arr.length) {
            return false;
        }
        arr[size++] = x;
        return true;
    }

    public int pop() {
        if(size == 0) {
            return -1;
        }
        return arr[--size];
    }

    public int peek() {
        if(size == 0) {
            return -1;
        }
        return arr[size-1];
    }

    public boolean empty() {
        if(size == 0) {
            return true;
        }
        return false;
    }

    public int size() {
        return size;
    }
}

队列：
队列是只允许在一段进行插入操作，在另一端进行删除操作的线性表，队列具有先进先出的特性，进行插入操作的一端称为队尾，进行删除操作的一端称为队首。
队列也可以用顺序表和链表实现，如果使用数组的结构，出队列在数组头上出数据，效率比较低。

代码实现：

class Node {
    int val;
    Node next;

    public Node(int val) {
        this.val = val;
    }
}
public class MyQueue {
    private Node head = null;
    private Node tail = null;
    private int size = 0;

    public void offer(int x) {
        Node node = new Node(x);
        if(head == null) {
            head = node;
            tail = node;
            return;
        }
        tail.next = node;
        tail = node;
        size++;
    }

    public int pop() {
        if(size == 0) {
            throw new RuntimeException("队列为空");
        }
        size--;
        Node node = head;
        head = head.next;
        if(head == null) {
            tail = null;
        }
        return node.val;

    }

    public int peek() {
        if(size == 0) {
            throw new RuntimeException("队列为空！");
        }
        return head.val;
    }

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

    public int size() {
        return size;
    }
}

数组循环队列：
说明：

• 需要一个变量 front 标志队首位置
• 需要一个变量 rear 标志队尾的下一个位置
• 插入元素时 front +1；
• 删除元素时 rear -1;
• 每次更新时 front = (front + 1) % 数组长度 （rear同理）
• 当 front 和 rear 相隔为1 时，数组可能为空也可能满了，所以需要定义一个类的属性size储存已储存的元素的个数。