JAVA实现LinkedList链表

最近在学习数据结构，不得不说数据结构是一门美丽的学问。

下面是我自己实现的LinkedList部分方法：

public class LinkList<T> {

    private Node first;

    private Node last;

    private int size;

    private class Node<T> {

        private T value;

        private Node<T> node;

        private Node(T t,Node<T> node) {
            this.node = node;
            this.value = t;
        }

    }

    public LinkList() {
        this.size = 0;
    }

    public void addFirst(T t) {

        if (this.first == null) {
            this.first = new Node(t,null);
            this.last = this.first;
            size++;

        } else {
            Node secondNode = this.first;
            this.first = new Node(t,secondNode);
            size++;
        }

    }

    public void addLast(T t) {
        if (this.first == null) {
            this.first = this.last = new Node(t,null);
            size++;
        } else {
            Node temporaryNode = this.last;
            Node lastNode = new Node(t,null);
            temporaryNode.node = lastNode;
            this.last = lastNode;
            size++;
        }
    }

    public void deleteFirst() {
        if (this.first == null) {

        } else {
            this.first = this.first.node;
            size--;
        }
    }

    public void deleteLast() {
        if (this.first == null) {
            throw new NoSuchElementException();
        }

        Node current = first;
        while (current.node != null) {
            current = current.node;
        }
        if (current == first) {
            first = last = null;
        }
        current = null;
        this.last = current;
        size--;

//        recursivelyDeleteLast(this.first);
    }

    public void recursivelyDeleteLast(Node<T> node) {
        while (node.node != this.last) {
            recursivelyDeleteLast(node.node);
        }

        node.node = null;
    }

    public boolean contains(T t) {
//        return recursivelyContainmentFinder(this.first,t);
        return indexOf(t) != -1;

    }

    public boolean recursivelyContainmentFinder(Node<T> node,T t) {

        if (node == null) {
            return false;
        }

        while (node.node.value != t) {
            recursivelyContainmentFinder(node.node,t);
        }

        return true;
    }


    public int recursivelyIndexFinder(Node<T> node,T t,int counter) {

        if (node == null) {
            return -1;
        }

        while (node.value != t) {
            ++counter;
            return  recursivelyIndexFinder(node.node,t,counter);
        }

        return counter;
    }

    public int indexOf(T t) {
//        return recursivelyIndexFinder(this.first,t,0);
        int index = 0;
        Node current = first;
        if (first == null) {
            return -1;
        }
        while (current.value != t) {
            if(current.node == null) {
                return -1;
            }
            current = current.node;
            index++;
        }
        return index;
    }

    public int size() {
        return size;
    }

    public void reverse() {
        Node temporaryNode = new Node(first.value,null);
        last = temporaryNode;
        Node nextNode = first.node;
        while (nextNode != null) {
            temporaryNode = new Node(nextNode.value,temporaryNode);
            nextNode = nextNode.node;

        }
        first = temporaryNode;

    }

}

里面最费时间的是reverse反转的方法实现，但是最后证明代码还是很简洁的嘻嘻嘻。

上面的代码里经常出现的recursively是我尝试使用递归来解决问题，后来发现使用while也可以，然后就注释掉啦。