数据结构与算法之手写LinkedList(Java)

public class LinkedList<T> {

    private final Node<T> head;

    private final Node<T> tail;

    private int size;

    public <T> LinkedList() {
        head = new Node<>();
        tail = new Node<>();
        head.next = tail;
        tail.pre = head;
    }

    public void add(T t) {
        Node node = new Node<T>();
        node.data = t;
        // 第一次插入
        if (head.next == tail) {
            head.next = node;
            tail.pre = node;
            node.pre = head;
            node.next = tail;
        } else {
            // 头插
//            node.next = head.next;
//            head.next.pre = node;
//            head.next = node;
//            node.pre = head;
            // 尾插
            node.pre = tail.pre;
            tail.pre.next = node;
            node.next = tail;
            tail.pre = node;
        }
        size++;
    }

    public void remove(int index) {
        Node<T> node = getNode(index);
        if (node == null) {
            return;
        }
        node.pre.next = node.next;
        node.next.pre = node.pre;
        size--;
    }

    public void set(int index, T t) {
        Node<T> node = getNode(index);
        if (node == null) {
            return;
        }
        node.data = t;
    }

    public T get(int index) {
        Node<T> node = getNode(index);
        return node == null ? null : node.data;
    }

    public int size(){
        return size;
    }
    
    public void delete(T t) {
        if (head.next == tail) {
            return;
        }
        Node<T> currentNode = head;
        for (int i = 0; i < size; i++) {
            currentNode = currentNode.next;
            if (currentNode.data == t) {
                currentNode.pre.next = currentNode.next;
                currentNode.next.pre = currentNode.pre;
                size--;
                i--;
                currentNode = currentNode.pre;
            }
        }
    }

    private Node<T> getNode(int index) {
        if (head.next == tail) {
            return null;
        }
        Node<T> currentNode = head;
        for (int i = 0; i <= index; i++) {
            currentNode = currentNode.next;
            if (i < index && currentNode.next == tail) {
                return null;
            }
        }
        return currentNode;
    }

    class Node<T> {

        private Node<T> pre;

        private Node<T> next;

        private T data;

    }
}