数据结构 - 单链表

单链表：

简单的链表结构，对象方式实现。通常，单链表实际很少使用，但不失为一个好的学习工具。

没有经过严格的测试，用于学习理解，如有错误，欢迎指正。

复杂度：

头插和尾插：O(1)

中间插入：O(n)

头删：O(1)

尾删：O(n)

中间删：O(n)

按元素删：O(n)

查元素：O(n)

改元素：O(n)

获取长度：O(1)

获取大小：O(1)

package collections;

import java.util.Iterator;

public class SingleLinkedList<T> implements Iterable {
    private Node<T> head;
    private Node<T> cur;
    private int len;

    @Override
    public Iterator iterator() {
        return new SingleLinkedListIterator<>(head);
    }

    public SingleLinkedList() {
        this.head = new Node<>(null, null);
        this.cur = head;
        this.len = 0;
    }

    /**
     * add before
     *
     * @param var Node{var}
     */
    public void push(T var) {
        head.setNext(new Node<>(var, head.getNext()));
        len++;
    }

    /**
     * add last
     *
     * @param var Node{var}
     */
    public void append(T var) {
        Node<T> newNode = new Node<>(var, null);
        cur.setNext(newNode);
        cur = newNode;
        len++;
    }

    /**
     * add element by index
     *
     * @param index   add position
     * @param element element
     */
    public void insert(int index, T element) {
        if (isEmpty() && index == 0) {
            push(element);
        }
        checkIndex(index);
        Node<T> lastNode = getLastNode(index);
        lastNode.setNext(new Node<>(element, lastNode.getNext()));
        len++;
    }

    /**
     * remove last
     */
    public void pop() {
        if (isEmpty()) {
            return;
        }
        Node<T> lastNode = head;
        while (lastNode.getNext().getNext() != null) {
            lastNode = lastNode.getNext();
        }
        lastNode.setNext(null);
        cur = lastNode;
        len--;
    }

    /**
     * check index
     *
     * @param index position
     */
    private void checkIndex(int index) {
        if (index > len - 1 || index < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
    }

    /**
     * get last node by index
     *
     * @param index current index
     * @return last node
     */
    private Node<T> getLastNode(int index) {
        int i = 0;
        Node<T> lastNode = head;
        while (i++ != index && lastNode.getNext().getNext() != null) {
            lastNode = lastNode.getNext();
        }
        return lastNode;
    }

    /**
     * remove node by index
     *
     * @param index node index from 0 to (length - 1)
     */
    public void pop(int index) {
        checkIndex(index);
        // left remove
        if (index == 0) {
            Node<T> firstNode = head.getNext();
            head.setNext(firstNode.getNext());
            firstNode.setNext(null);
            len--;
            if (len == 0) {
                cur = head;
            }
            return;
        }
        // right remove
        if (index == len - 1) {
            pop();
            return;
        }
        // center remove
        Node<T> lastNode = getLastNode(index);
        Node<T> curNode = lastNode.getNext();
        lastNode.setNext(curNode.getNext());
        curNode.setNext(null);
        len--;
    }

    /**
     * remove element by target if existed
     *
     * @param target element removed
     */
    public void remove(T target) {
        Node<T> lastNode = head;
        Node<T> curNode = head;
        while (curNode != null && curNode.getVar() != target) {
            lastNode = curNode;
            curNode = curNode.getNext();
        }
        if (curNode == cur) {
            lastNode.setNext(null);
            cur = lastNode;
            len--;
            return;
        }
        if (curNode != null) {
            lastNode.setNext(curNode.getNext());
            curNode.setNext(null);
            len--;
        }
    }

    /**
     * check element exist
     *
     * @param element element checked
     * @return if exist return index, if not return -1
     */
    public int contain(T element) {
        if (isEmpty()) {
            return -1;
        }
        int i = 0;
        Node<T> currentNode = head.getNext();
        while (currentNode.getVar() != element) {
            currentNode = currentNode.getNext();
            if (currentNode == null) {
                return -1;
            }
            i++;
        }
        return i;
    }

    /**
     * update element value
     *
     * @param index element position
     * @param element element updated
     */
    public void update(int index, T element) {
        if (isEmpty()) {
            return;
        }
        checkIndex(index);
        getLastNode(index).getNext().setVar(element);
    }

    /**
     * get length
     *
     * @return size of list
     */
    public int length() {
        return len;
    }

    /**
     * check empty
     *
     * @return if empty true, else false
     */
    public boolean isEmpty() {
        return len == 0;
    }

}

class Node<T> {
    private T var;
    private Node<T> next;

    public Node(T var, Node<T> next) {
        this.var = var;
        this.next = next;
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

    public Node<T> getNext() {
        return next;
    }

    public void setNext(Node<T> next) {
        this.next = next;
    }
}

class SingleLinkedListIterator<T> implements Iterator {

    private Node<T> cursor;

    public SingleLinkedListIterator(Node<T> node) {
        this.cursor = node;
    }

    @Override
    public boolean hasNext() {
        if (cursor == null) {
            return false;
        }
        boolean flag = cursor.getNext() != null;
        cursor = cursor.getNext();
        return flag;
    }

    @Override
    public Object next() {
        return cursor;
    }
}