数据结构与算法 | 线性表 —— 链表

原文链接：https://wangwei.one/posts/java-data-structures-and-algorithms-linkedlist.html

链表

定义

逻辑结构上一个挨一个的数据，在实际存储时，并没有像顺序表那样也相互紧挨着。恰恰相反，数据随机分布在内存中的各个位置，这种存储结构称为线性表的链式存储。

由于分散存储，为了能够体现出数据元素之间的逻辑关系，每个数据元素在存储的同时，要配备一个指针，用于指向它的直接后继元素，即每一个数据元素都指向下一个数据元素（最后一个指向NULL(空)）。这种结构成为 “单向链表”。

在单向链表的基础上，给各个结点额外配备一个指针变量，用于指向每个结点的直接前趋元素。这样的链表被称为“双向链表”或者“双链表”。

当单向链表的尾部数据指向头部数据时，就构成了单向循环链表。

当双向链表的头部和尾部相互指向时，就构成了双向循环链表。

单向链表

单向链表在插入元素、删除元素时，需要获取前驱元素，需要从head开始遍历，时间复杂度为O(n)。

根据index查询对应元素，也需要从head开始遍历，时间复杂度为O(n)。

代码实现

package one.wangwei.algorithms.datastructures.list.impl;

import one.wangwei.algorithms.datastructures.list.IList;

/**
 * Single Linked List
 *
 * @author https://wangwei.one
 * @date 2018/12/25
 */
public class SingleLinkedList<T> implements IList<T> {
   

    /**
     * size
     */
    private int size = 0;
    /**
     * head node
     */
    private Node<T> head;
    /**
     * tail node
     */
    private Node<T> tail;

    /**
     * add element
     *
     * @param element
     * @return
     */
    @Override
    public boolean add(T element) {
   
        return addLast(element);
    }

    /**
     * add element at index
     *
     * @param index
     * @param element
     * @return
     */
    @Override
    public boolean add(int index, T element) {
   
        if (index < 0 || index > size) {
   
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
        if (index == size) {
   
            return add(element);
        } else {
   
            return addBefore(index, element);
        }
    }

    /**
     * Add Last element
     *
     * @param element
     * @return
     */
    private boolean addLast(T element) {
   
        Node<T> last = tail;
        Node<T> newNode = new Node<>(null, element);
        tail = newNode;
        // if linked list is empty
        if (last == null) {
   
            head = newNode;
        } else {
   
            last.next = newNode;
        }
        size++;
        return true;
    }

    /**
     * add element before certain element
     *
     * @param index
     * @param element
     * @return
     */
    private boolean addBefore(int index, T element) {
   
        checkPositionIndex(index);
        // prev node
        Node<T> prev = null;
        Node<T> x = head;
        for (int i = 0; i < index; i++) {
   
            prev = x;
            x = x.next;
        }
        // current node
        Node<T> current = x;
        // new node
        Node<T> newNode = new Node<>(current, element);
        // if current node is head
        if (prev == null) {
   
            head = newNode;
        } else {
   
            prev.next = newNode;
        }
        size++;
        return true;
    }

    /**
     * remove element
     *
     * @param element
     * @return
     */
    @Override
    public boolean remove(T element) {
   
        Node<T> prev = null;
        Node<T> x = head;
        if (element == null) {
   
            while (x != null && x.element != null) {
   
                prev = x;
                x = x.next;
            }
        } else {
   
            while (x != null && !x.element.equals(element)) {
   
                prev = x;
                x = x.next;
            }
        }

        // if this linked is null OR don't find element
        if (x == null) {
   
            return false;
        }

        Node<T> next = x.next;

        // if delete node is head
        if (prev == null) {
   
            head = next;
        } else {
   
            prev.next = next;
        }
        // if delete node is tail
        if (next == null) {
   
            tail = prev;
        }

        // for GC
        x.element = null;
        x = null;

        size--;
        return true;
    }

    /**
     * remove element by index
     *
     * @param index
     * @return
     */
    @Override
    public T remove(int index) {
   
        checkPositionIndex(index);
        Node<T> prev = null;
        Node<T> x = head;
        for (int i = 0; i < index; i++) {
   
            prev = x;
            x = x.next;
        }

        // if linked is empty
        if (x == null) {
   
            return null;
        }

        Node<T> next = x.next;

        // if delete node is head
        if (prev == null) {
   
            head = next;
        } else {
   
            prev.next = next;
        }

        // if delete node is tail
        if (next == null) {
   
            tail = prev;
        }
        size--;
        return x.element;
    }

    /**
     * set element by index
     *
     * @param index
     * @param element
     * @return old element
     */
    @Override
    public T set(int index, T element) {
   
        checkPositionIndex(index);
        Node<T> node = node(index);
        T oldElement = node.element;
        node.element = element;
        return oldElement;
    }
    
    /**
     * get element by index
     *
     * @param index
     * @return
     */
    @Override
    public T get(int index) {
   
        Node<T> node = node(index);
        return node == null ? null : node.element;
    }

    /**
     * get element by index
     *
     * @param index
     * @return
     */
    private Node<T> node(int index) {
   
        checkPositionIndex(index);
        Node<T> x = head;
        for (int i = 0; i < index; i++) {
   
            x = x.next;
        }
        return x;
    }

    /**
     * check index
     *
     * @param index
     */
    private void checkPositionIndex(int index) {
   
        if (index < 0 || index >= size) {
   
            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
        }
    }

    /**
     * clear list
     */
    @Override
    public void clear() {
   
        for (Node<T