1.3 基础数据结构

1. 链表

// 单向链表
public class Node {
    int value;
    Node next;

    public Node(int value) {
        this.value = value;
    }
}
// 单向链表反转
    public Node reserve(Node n) {
        Node pre = null, next;
        while (n != null) {
            next = n.next;
            n.next = pre;
            pre = n;
            n = next;
        }
        return pre;
    }

    // 删除特定值
    public Node removeValue(Node n, int value) {
        if (n == null) {
            return n;
        }
        Node re = n;
        while (re != null && re.value == value) {
            re = re.next;
        }
        Node head = re, pre = re;
        while (head != null) {
            if (head.value == value) {
                pre.next = head.next;
            } else {
                pre = head;
            }
            head = head.next;
        }
        return re;
    }
    // 双向链表
public class DoubleNode extends Node {
    Node pre;

    public DoubleNode(int value) {
        super(value);
    }
}

2. 数组

3. 栈、队列

栈 先进后出。push, pop, peek 方法
队列 先进先出。offer, poll, peek 方法

// 使用数组和链表实现队列和栈
public class LinkedQueue extends AbstractQueue<Integer> {
    private Node head;
    private Node tail;
    private int size;

    @Override
    public Iterator<Integer> iterator() {
        List<Integer> list = new ArrayList<>();
        Node h = head;
        while (h != null) {
            list.add(h.value);
            h = h.next;
        }
        return list.iterator();
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean offer(Integer val) {
        Node curr = new Node(val);
        if (tail == null) {
            head = tail = curr;
        } else {
            tail.next = curr;
            tail = curr;
        }
        size++;
        return true;
    }

    @Override
    public Integer poll() {
        if (head == null) {
            return null;
        }
        int re = head.value;
        head = head.next;
        if (head == null) {
            tail = null;
        }
        size--;
        return re;
    }

    @Override
    public Integer peek() {
        return head == null ? null : head.value;
    }
}

4. 用两个栈来实现，最小栈和正常栈

import java.util.Stack;

public class MinStack {
    private Stack<Integer> dataStack;
    private Stack<Integer> minStack;

    public MinStack() {
        dataStack = new Stack<>();
        minStack = new Stack<>();
    }

    public Integer pop() {
        if (dataStack.isEmpty()) {
            throw new RuntimeException("stack is empty!");
        }
        Integer v = dataStack.pop();
        if (v == minStack.peek()) {
            minStack.pop();
        }
        return v;
    }

    public void push(Integer v) {
        if (minStack.isEmpty()) {
            minStack.push(v);
        } else if (getMin() > v) {
            minStack.push(v);
        }
        dataStack.push(v);
    }

    public Integer getMin() {
        if (minStack.isEmpty()) {
            throw new RuntimeException("stack is Empty!");
        }
        return minStack.peek();
    }
}

4. 用队列实现栈，用栈实现队列

// 两个队列， 实现栈
// pop 待出队列，和数据队列
// push 数据队列正常加

// 两个栈实现队列
// push 数据队列正常放
// pop 将队列中的数据取出，返回最后一个元素

利用两个队列或者栈来回倒腾

5. 堆

比较器： 返回值 -1 ：第一个参数在前，0 不换，1 第二个参数在前

堆： 完全二叉树，可以用数组表示或者Node表示
i 位置的左节点 2i + 1
        右节点 2i + 2
        父节点 (i - 1) / 2
大根堆 任一子树的根节点是最大值
小根堆 任一子树的根节点是最小值