链表，单链表，双向（单向）循环链表

动态链表

单链表：

// 头结点是指链表中的第一个结点，有真实头结点和虚拟头结点之分；
（1）真实头结点：其第一个结点用于存储数据（一般使用真实头结点）。
（2）虚拟头结点：其第一个结点不许存储数据。
（3）头指针：仅仅是一个引用变量，存储头结点地址的指针而已，无前驱结点，有后继。
（4）尾指针：同头指针，不过是链表中最后一个结点的指针而已,尾部指向null，有前驱无后继。

向单链表添加元素：

要在元素3处插入元素，先设置指针p，让p指向要插入元素的前一个元素，例如图中要在元素3处插入元素，先让p找到元素2，因为元素2中存有元素3的地址，然后把元素2中的地址给新元素，让新元素指向元素3.再让元素2指向新元素即可。
// 借助建表进行理解，实际上并不存在角标这个元素。

单链表删除元素：

// 删除4号元素，将元素4中存放的元素5的地址替换元素3中原来存放的元素4的地址，将元素4的地址置空，直接的说就是让元素3直接指向元素5，释放元素4,即可。
// 若是头指针和尾指针都指向同一元素，那么删除的时候，只要把头指针和尾指针分别置空即可。

代码部分：
// 定义链表类，但是还有另外一个结点类，所以我们需要使用内部类对结点进行定义。在这里，链表在最外层，结点在内部，所以链表是外部类，结点是内部类。
// 要是用toString方法，因为要是不用toString的话结果就是数据的名称，而非数据本身，所以使用toString方法得到数据内容。打印结点实际上就是打印结点中所存储的数据。
// 这里是动态的链表，自动扩容，所以不用设置默认值。

//单向链表
public class LinkedSinglyList<E> implements List<E> {
   

    //定义结点对象
    private class Node {
   
        E data;     //数据域
        Node next;  //指针域
        public Node(){
   
            this(null,null);
        }
        public Node(E data) {
   
            this(data,null);
        }
        public Node(E data, Node next) {
   
            this.data = data;
            this.next = next;
        }
        @Override
        public String toString() {
   
            return data.toString();
        }
    }
    private Node head;  //头指针
    private Node tail;  //尾指针
    private int size;   //元素的个数

    public LinkedSinglyList() {
   
        head = null;
        tail = null;
        size = 0;
    }

    public LinkedSinglyList(E[] arr) {
   
        if (arr == null || arr.length == 0) {
   
            throw new IllegalArgumentException("arr is null");
        }
        for (int i = 0; i < arr.length; i++) {
   
            add(arr[i]);
        }
    }

    @Override
    public void add(E element) {
   
        add(size, element);
    }

    @Override
    public void add(int index, E element) {
   
        if (index < 0 || index > size) {
   
            throw new IllegalArgumentException("add index out of range");
        }
        Node n = new Node(element);
        if (size == 0) {
   
            head = n;
            tail = n;
        } else if (index == 0) {
   
            n.next = head;
            head = n;
        } else if (index == size) {
   
            tail.next = n;
            tail = n;
        } else {
   
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
   
                p = p.next;
            }
            n.next = p.next;
            p.next = n;
        }
        size++;
    }

    @Override
    public void remove(E element) {
   
        int index = indexOf(element);
        if (index != -1) {
   
            remove(index);
        }
    }
    @Override
    public E remove(int index) {
   
        if (index < 0 || index >= size) {
   
            throw new IllegalArgumentException("remove index out of range");
        }
        E ret = null;
        if (size == 1) {
   
            ret = head.data;
            head = null;
            tail = null;
        } else if (index == 0) {
   
            Node n = head;
            ret = n.data;
            head = n.next;
            n.next = null;
        } else if (index == size - 1) {
   
            Node p = head;
            while (p.next != tail) {
   
                p = p.next;
            }
            ret = tail.data;
            p.next = null;
            tail = p;
        } else {
   
            Node p = head;
            for (int i = 0; i < index - 1; i++) {
   
                p = p.next;
            }
            Node n = p.next;
            ret = n.data;
            p.next = n.next;
            n.next = null;
        }
        size--;
        return ret;
    }

    @Override
    public E get(int index) {
   
        if (index < 0 || index >= size) {
   
            throw new IllegalArgumentException("get index out of range");
        }
        if (index == 0) {
   
            return head.data;
        } else if (index == size - 1) {
   
            return tail.data;
        } else {
   
            Node p = head;
            for (int i = 0; i < index; i++) {
   
                p = p.next;
            }
            return p.data;
        }
    }

    @Override
    public E set(int index, E element) {
   
        if (index < 0 || index >= size) {
   
            throw new IllegalArgumentException("get index out of range");
        }
        E ret = null;
        if (index == 0) {
   
            ret = head.data;
            head.data = element;
        } else if (index == size - 1) {
   
            ret = tail.data;
            tail.data = element;
        } else {
   
            Node p = head;
            for (int i = 0; i < index; i++) {
   
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }
        return ret;
    }

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

    @Override
    public int indexOf(E element) {
   
        Node p = head;
        int index = 0;
        while (!p.data.equals(element)) {
   
            p = p.next;
            index++;
            if (p == null) {
   
                return -1;
            }
        }
        return index;
    }

    @Override
    public boolean contains(E element) {
   
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
   
        return size == 0 && head == null && tail == null;
    }