1
Stack<Integer> stack = new Stack<>();
2
stack.push(1); // 压栈：放入一片薯片
3
stack.peek();  // 瞅一眼栈顶的薯片（但忍住不吃）
4
stack.pop();   // 出栈：终于吃掉栈顶的薯片！
5
stack.size();  // 看看桶里还剩几片

1
public class MyStack {
2
    int[] array = new int[3]; // 初始容量3，不够吃了就扩容！
3
    int size = 0;
4

5
    // 压栈：薯片塞进桶
6
    public int push(int e) {
7
        ensureCapacity(); // 桶满了？换个大桶！
8
        array[size++] = e;
9
        return e;
10
    }
11

12
    // 出栈：吃掉最上面的薯片
13
    public int pop() {
14
        int e = peek(); // 看一眼栈顶
15
        size--;         // 薯片-1
16
        return e;
17
    }
18

19
    // 偷偷瞅一眼栈顶
20
    public int peek() {
21
        if (empty()) throw new RuntimeException("桶空了，别看了！");
22
        return array[size - 1]; // 注意是size-1，不是size=1（老板扣鸡腿！）
23
    }
24

25
    // 扩容：吃货的终极奥义
26
    private void ensureCapacity() {
27
        if (size == array.length) {
28
            array = Arrays.copyOf(array, size * 2); // 容量翻倍，继续囤货！
29
        }
30
    }
31
}

1
Queue<Integer> queue = new LinkedList<>();
2
queue.offer(1); // 排队：队尾加入
3
queue.poll();   // 出队：队头的人拿到奶茶了！
4
queue.peek();   // 偷看队头是谁

1
public class MyQueue {
2
    static class ListNode {
3
        int value;
4
        ListNode next;
5
        ListNode prev;
6
        ListNode(int value) { this.value = value; }
7
    }
8

9
    ListNode first; // 队头：马上要点单的人
10
    ListNode last;  // 队尾：刚来排队的萌新
11
    int size = 0;
12

13
    // 入队：萌新乖乖排到队尾
14
    public void offer(int e) {
15
        ListNode newNode = new ListNode(e);
16
        if (first == null) {
17
            first = last = newNode; // 队列为空，你就是第一个！
18
        } else {
19
            last.next = newNode;    // 原队尾指向新节点
20
            newNode.prev = last;    // 新节点指回原队尾
21
            last = newNode;         // 更新队尾
22
        }
23
        size++;
24
    }
25

26
    // 出队：队头的人拿到奶茶离开
27
    public int poll() {
28
        if (first == null) throw new RuntimeException("队都空了，别取了！");
29
        int value = first.value;
30
        if (first == last) {
31
            first = last = null; // 队列只剩一人，清空
32
        } else {
33
            first = first.next;  // 队头后移
34
            first.prev = null;   // 断开头节点的前驱
35
        }
36
        size--;
37
        return value;
38
    }
39
}

1
// 入队操作（保留一个空位法）
2
public boolean enQueue(int value) {
3
    if ((rear + 1) % capacity == front) return false; // 队满
4
    array[rear] = value;
5
    rear = (rear + 1) % capacity;
6
    return true;
7
}