线性表数据结构解读（二）链式存储结构LinkedList

 在上一篇文章中，我们详细介绍了线性表数据结构的原理以及顺序存储结构，并结合ArrayList源码进行了分析，相关文章大家可以点击这里回看我的博客：线性表数据结构解读（一）顺序存储结构ArrayList 
    本篇文章，我将给大家继续解读线性表数据结构，这次我们来谈链式存储结构。

链式存储结构

链式存储结构是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。

我们将数据元素和下一个元素位置的结构称为链表的节点。若第一个节点只表示整个链表的起始位置，而无任何信息，称其为头结点。对于最后一个结点，后面无任何元素，其表示元素位置的地址用“^”来表示，称其为尾结点，程序实现中用”null“表示。 
    链表中结点的表示必须要用到两个域，其中一个存放数组元素自身的信息ai，称其为数据域，另一个存放下一个元素的地址或位置，以保证链表的连续性，称其为指针。

链式存储结构的优缺点

优：删除和插入效率高
缺：查询效率低

链表的分类

单链表

是由第一个元素到最后一个元素构成的一个链，其特点是从第一个元素（可能有头指针和头结点）到最后一个元素（结束标志位^）够成的一个链，成为单链表。我们通过第一个元素的指针可以顺序找到后面元素所在的位置，因此所有操作全部是从第一个元素（头指针或头结点）开始的。

循环链表

在单链表中，最后一个元素的存储区域是^，如果将它指向第一个元素（头结点）位置，就构成了循环链表。循环链表的特点是在所有元素之间构成的一个环，从任何一个元素出发，都可以查找其他所有元素，同时还充分利用了空间。

双向循环链表

双向循环链表是单向循环链表的每个结点中，再设置一个指向其前驱结点的指针域。也就是说，可以从任何一个元素出发，向两个方向分别查找相应的元素，可以提高操作效率。

空的双向循环链表

在Java中，我们常见具有代表性的链式存储结构有很多，这里我们以LinkedList为例，进行分析，看看它内部是如何实现链式存储结构的，由于源码过长，这里我们重点分析增删改查和迭代器方法。

构造方法

public class LinkedList<E> extends AbstractSequentialList<E> implements
        List<E>, Deque<E>, Queue<E>, Cloneable, Serializable {

    private static final long serialVersionUID = 876323262645176354L;

    transient int size = 0;

    transient Link<E> voidLink;// 头指针

    private static final class Link<ET> {// 内部精简后的静态Link类，这个其实就是一个结点
        ET data;

        Link<ET> previous, next;// 双向链表

        Link(ET o, Link<ET> p, Link<ET> n) {
            data = o;
            previous = p;
            next = n;
        }
    }
    /**
     * LinkedList无参构造
     */
    public LinkedList() {
        // 实例化头指针
        voidLink = new Link<E>(null, null, null);
        // 分别让头指针的previous和next等于头指针
        voidLink.previous = voidLink;
        voidLink.next = voidLink;
    }

    /**
     * 接收一个Collection参数的LinkedList构造方法
     */
    public LinkedList(Collection<? extends E> collection) {
        this();
        addAll(collection);
    }

迭代器

    // 作为一个List，LinkedList肯定也包含一个迭代器
    private static final class LinkIterator<ET> implements ListIterator<ET> {
        int pos, expectedModCount;

        final LinkedList<ET> list;
        // link表示当前正在遍历的指针，lastLink表示最后的节点
        Link<ET> link, lastLink;

        LinkIterator(LinkedList<ET> object, int location) {
            list = object;
            expectedModCount = list.modCount;
            if (location >= 0 && location <= list.size) {
                // pos ends up as -1 if list is empty, it ranges from -1 to
                // list.size - 1
                // if link == voidLink then pos must == -1
                link = list.voidLink;
                if (location < list.size / 2) {
                    for (pos = -1; pos + 1 < location; pos++) {
                        link = link.next;
                    }
                } else {
                    for (pos = list.size; pos >= location; pos--) {
                        link = link.previous;
                    }
                }
            } else {
                throw new IndexOutOfBoundsException();
            }
        }
        // 在迭代器中的添加方法，单向链表
        public void add(ET object) {
            if (expectedModCount == list.modCount) {
                Link<ET> next = link.next;// 拿到当前结点的下一个结点
                Link<ET> newLink = new Link<ET>(object, link, next);// new一个新的Link
                link.next = newLink;// 把当前结点的下一个结点指向newLink
                next.previous = newLink;// 把先前结点的下一个结点的前驱指向newLink
                link = newLink;// 最后把当前结点link变为newLink
                lastLink = null;// 指向新结点后，把LastLink置空
                pos++;
                expectedModCount++;
                list.size++;// 长度+1
                list.modCount++;// 计量器+1
            } else {
                throw new ConcurrentModificationException();
            }
        }

        public boolean hasNext() {
            return link.next != list.voidLink;
        }

        public boolean hasPrevious() {
            return link != list.voidLink;
        }

        public ET next() {
            if (expectedModCount == list.modCount) {
                LinkedList.Link<ET> next = link.next;
                if (next != list.voidLink) {
                    lastLink = link = next;
                    pos++;
                    return link.data;
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();
        }

        public int nextIndex() {
            return pos + 1;
        }

        public ET previous() {
            if (expectedModCount == list.modCount) {
                if (link != list.voidLink) {
                    lastLink = link;
                    link = link.previous;
                    pos--;
                    return lastLink.data;
                }
                throw new NoSuchElementException();
            }
            throw new ConcurrentModificationException();
        }

        public int previousIndex() {
            return pos;
        }
        // 移除当前结点
        public void remove() {
            if (expectedModCount == list.modCount) {
                if (lastLink != null) {
                    Link<ET> next = lastLink.next;
                    Link<ET> previous = lastLink.previous;
                    next.previous = previous;
                    previous.next = next;
                    if (lastLink == link) {
                        pos--;
                    }
                    link = previous;
                    lastLink = null;
                    expectedModCount++;
                    list.size--;
                    list.modCount++;
                } else {
                    throw new IllegalStateException();
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }
        // 修改当前结点
        public void set(ET object) {
            if (expectedModCount == list.modCount) {
                if (lastLink != null) {
                    lastLink.data = object;
                } else {
                    throw new IllegalStateException();
                }
            } else {
                throw new ConcurrentModificationException();
            }
        }
    }

添加方法

    /**
     * 添加方法，在指定位置进行添加
     * @param location the index at which to insert.
     * @param object the object to add.
     * @throws IndexOutOfBoundsException
     *             if {@code location < 0 || location > size()}
     */
    @Override
    public void add(int location, E object) {
        if (location >= 0 && location <= size) {// 在链表的中间添加
            Link<E> link = voidLink;
            // 为了提高效率，采用二分法的思想，需要判断前半段和后半段进行插入
            if (location < (size / 2)) {// 表示在前半段
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {// 表示在后半段
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            // 将当前结点的前一结点赋值给previous
            Link<E> previous = link.previous;
            // 初始化先创建结点newLink，其数据域是object，前面的结点是previous，后面的结点是link
            Link<E> newLink = new Link<E>(object, previous, link);
            // 让previous.next指向新节点
            previous.next = newLink;
            // 同时让link.previous指向新节点
            link.previous = newLink;
            size++;// 长度+1
            modCount++;// 计量器+1
        } else {
            throw new IndexOutOfBoundsException();
        }
    }

    /**
     * 将元素(E)添加到LinkedList中
     * @param object the object to add.
     * @return always true
     */
    @Override
    public boolean add(E object) {
        return addLastImpl(object);
    }

   /**
     * 在最猴添加元素的方法
     */
    private boolean addLastImpl(E object) {
        // 将头结点的previous，其实就是头结点自己，赋值给oldLast
        Link<E> oldLast = voidLink.previous;
        // 新建一个要插入的新节点，其数据域是object，previous结点是oldLast，next结点是voidLink
        Link<E> newLink = new Link<E>(object, oldLast, voidLink);
        // 让头指针的前面previous指向新建结点
        voidLink.previous = newLink;
        // 让oldLast.next指向新建结点
        oldLast.next = newLink;
        size++;// 长度+1
        modCount++;// 计量器+1
        return true;
    }

为了方便大家理解，下面我将画图来解释下插入结点的实现机制

删除方法

    /**
     * Removes the object at the specified location from this {@code LinkedList}.
     * @param location the index of the object to remove
     * @return the removed object
     * @throws IndexOutOfBoundsException
     *             if {@code location < 0 || location >= size()}
     */
    @Override
    public E remove(int location) {
        // 先判断location >= 0 && location < size
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            // 采用二分法的思想，先找前半段
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {// 再找后半段
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            Link<E> previous = link.previous;
            Link<E> next = link.next;
            previous.next = next;// 待删除结点的前一结点的后指针指向待删除结点的后一个结点
            next.previous = previous;// 待删除结点的后一结点的前指针指向待删除结点的前一个结点
            size--;// 长度-1
            modCount++;// 计量器+1
            // 返回移除结点的内容
            return link.data;
        }
        throw new IndexOutOfBoundsException();
    }

获取方法

    @Override
    public E get(int location) {
        // 先判断location >= 0 && location < size
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            // 采用二分法的思想，先找前半段
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {// 再找后半段
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            return link.data;// 返回结点内容
        }
        throw new IndexOutOfBoundsException();
    }

修改方法

    /**
     * Replaces the element at the specified location in this {@code LinkedList}
     * with the specified object.
     *
     * @param location
     *            the index at which to put the specified object.
     * @param object
     *            the object to add.
     * @return the previous element at the index.
     * @throws ClassCastException
     *             if the class of an object is inappropriate for this list.
     * @throws IllegalArgumentException
     *             if an object cannot be added to this list.
     * @throws IndexOutOfBoundsException
     *             if {@code location < 0 || location >= size()}
     */
    @Override
    public E set(int location, E object) {
        // 先判断location >= 0 && location < size
        if (location >= 0 && location < size) {
            Link<E> link = voidLink;
            // 采用二分法的思想，先找前半段
            if (location < (size / 2)) {
                for (int i = 0; i <= location; i++) {
                    link = link.next;
                }
            } else {// 再找后半段
                for (int i = size; i > location; i--) {
                    link = link.previous;
                }
            }
            // 做数据修改
            E result = link.data;
            link.data = object;
            return result;
        }
        throw new IndexOutOfBoundsException();
    }