前面所讲的动态数组、栈、队列底层依托静态数组，靠resize解决固定容量问题。

而链表是真正的动态数据结构，最简单的动态数据结构，学习链表能是我们更深入的理解引用（指针），更深入的理解递归。

优点：真正的动态，不需要处理固定容量的问题。

缺点：丧失了随机访问的能力。

下面简单定义一个链表：

public class LinkedList<E> {

    //节点
    private class Node{
        //元素e
        public E e;
        //指针
        public Node next;
        
        public Node(E e, Node next){
            //用户给e赋值
            this.e = e;
            //用户给next赋值
            this.next = next;
        }
        
        public Node(E e){
            //用户只传来e，调用有两个参数的构造方法
            this(e, null);
        }

        public Node(){
            //用户什么都没传，调用有两个参数的构造方法
            this(null, null);
        }

        @Override
        public String toString(){
            return e.toString();
        }
    }

}

1.往链表头添加元素

链表应该有个头节点（head）来指向下一个节点。

例如添加一个新的节点：666

第一步：把这个666节点指向head节点：node.next = head

第二步：让head = node;

这样就成功的插入一个新的节点了。

2.往链表中间添加元素

例如在”索引“prev为2的位置添加元素666：

第一步：索引prev要找到索引为2前一个元素及索引为1的元素：

第二步：将要插入的元素指向要插入的索引位置： node.next = prev.next

第三步：改变prev指向，指向node : prev.next = node

添加完毕

上面的添加元素执行顺序是不能改变的。

public class LinkedList<E> {
    private class Node{
        public E e;
        public Node next;
        public Node(E e, Node next){this.e = e;this.next = next; }
        public Node(E e){this(e, null);}
        public Node(){this(null, null);}
        @Override
        public String toString(){return e.toString();}
    }
    
    //头节点
    private Node head;
    //链表元素个数
    private int size;

    //构造函数
    public LinkedList(){
        //初始化头结点为null，size=0
        head = null;
        size = 0;
    }

    // 获取链表中的元素个数
    public int getSize(){
        return size;
    }

    // 返回链表是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在链表头添加新的元素e
    public void addFirst(E e){
//        Node node = new Node(e);
//        node.next = head;
//        head = node;
        head = new Node(e, head);
        size ++;
    }

    // 在链表的index(0-based)位置添加新的元素e
    // 在链表中不是一个常用的操作，练习用：）
    public void add(int index, E e){

        if(index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }
        //如果链表没有元素，则添加第一个元素
        if(index == 0) {
            addFirst(e);
        } else {
            //否则index - 1后的位置插入元素
            Node prev = head;
            for(int i = 0 ; i < index - 1 ; i ++) {
                prev = prev.next;
            }
            prev.next = new Node(e, prev.next);
            size ++;
        }
    }

    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }
}

3.为链表设立虚拟头节点

第一个元素：dummyHead.next,这样就如果第一个节点的改变就不需要特殊处理了。

public class LinkedList<E> {

    private class Node{
        public E e;
        public Node next;
        public Node(E e, Node next){this.e = e;this.next = next;}
        public Node(E e){this(e, null);}
        public Node(){this(null, null); }
        @Override
        public String toString(){return e.toString();}
    }

    //虚拟头节点
    private Node dummyHead;
    //链表元素个数
    private int size;

    public LinkedList(){
        //初始化头结点为null
        dummyHead = new Node(null , null);
        size = 0;
    }

    // 获取链表中的元素个数
    public int getSize(){
        return size;
    }

    // 返回链表是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 在链表的index(0-based)位置添加新的元素e
    // 在链表中不是一个常用的操作，练习用：）
    public void add(int index, E e){

        if(index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index.");
        }
        //从虚拟头结点开始
        Node prev = dummyHead;
        for(int i = 0 ; i < index ; i ++) {
            prev = prev.next;
        }
        prev.next = new Node(e, prev.next);
        size ++;
    }

    // 在链表头添加新的元素e
    public void addFirst(E e){
        add(0, e);
    }

    // 在链表末尾添加新的元素e
    public void addLast(E e){
        add(size, e);
    }
}

4.链表的遍历、查询和修改。

    // 获得链表的第index(0-based)个位置的元素
    // 在链表中不是一个常用的操作，练习用：）
    public E get(int index){

        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed. Illegal index.");
        }
        Node cur = dummyHead.next;
        for(int i = 0 ; i < index ; i ++) {
            cur = cur.next;
        }
        return cur.e;
    }

    // 获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }

    // 获得链表的最后一个元素
    public E getLast(){
        return get(size - 1);
    }

    // 修改链表的第index(0-based)个位置的元素为e
    // 在链表中不是一个常用的操作，练习用：）
    public void set(int index, E e){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Set failed. Illegal index.");
        }
        Node cur = dummyHead.next;
        for(int i = 0 ; i < index ; i ++) {
            cur = cur.next;
        }
        cur.e = e;
    }

    // 查找链表中是否有元素e
    public boolean contains(E e){
        Node cur = dummyHead.next;
        while(cur != null){
            if(cur.e.equals(e)) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

5.从链表中删除元素

例如要删除索引为2位置的元素：

此时只需要将待删除元素的前一个元素的指针prev指向待删除元素索引位置的下一个元素：prev.next = delNode.next

最后处理删除的节点令其指向null即可。

 // 从链表中删除index(0-based)位置的元素, 返回删除的元素
    // 在链表中不是一个常用的操作，练习用：）
    public E remove(int index){
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("Remove failed. Index is illegal.");
        }
        Node prev = dummyHead;
        for(int i = 0 ; i < index ; i ++) {
            //待删除节点的之前节点
            prev = prev.next;
        }
        //retNode是要删除的节点
        Node retNode = prev.next;
        prev.next = retNode.next;
        retNode.next = null;
        size --;
        //把删除的节点return掉
        return retNode.e;
    }

    // 从链表中删除第一个元素, 返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    // 从链表中删除最后一个元素, 返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从链表中删除元素e
    public void removeElement(E e){

        Node prev = dummyHead;
        while(prev.next != null){
            if(prev.next.e.equals(e)) {
                break;
            }
            prev = prev.next;
        }

        if(prev.next != null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size --;
        }
    }