2018年10月25日

由于数组需要一块连续的内存空间，所以插入和删除时会使部分元素挪动，其时间复杂度为 ，为了避免这种开销，可以使用链表这种不连续内存的数据结构。数组和链表的内存分布：

假如内存剩余可用空间大于100MB，但是其可用空间不是连续的，所以申请100MB数组时会失败，而链表由于不需要连续的内存，其通过指针将一组零散的内存块串起来，所以此时使用链表就不会有问题。

1，单链表

链表是由一系列的节点组成，对于单链表而言，每个节点除了存储元素外，还要存储指向下一个节点的地址，称之为next；最后一个节点的next指向NULL：

向链表中插入元素，如向 与之间插入节点X，首先将的next指向X，然后将X指向：

删除链表中的元素，如删除，那么就将的next指向：

由此可见，链表的插入和删除操作，只需考虑相邻节点指针的改变，因此其时间复杂度均为。但是，在链表中随机访问某个位置的元素就不如数组高效了，只能从头开始遍历，直至找到所需的节点，因此其随机访问的时间复杂度为。

2，双向链表

如上图，双向链表比单链表多了一个前向指针prev，prev指向前一个节点，next指向后一个节点。

向链表中插入元素，如在A节点与B节点之间插入节点X，首先将A节点的next指向X节点，X节点的prev指向A节点；然后将X节点的next指向B节点，B节点的prev指向X：

删除链表中的元素，如删除元素B，那么首先将A节点的next指向B节点的下一个节点即C节点，再将C节点的prev指向A节点：

3，容器

JAVA中的LinkedList容器就是使用双向链表实现的，其结构如下：

可以看出，其实现了Queue和Deque接口，因此可以把其当做队列或双端队列来使用，同时也可以将其当做栈来使用。

使用LinkedList时，需要注意的是，当需要删除某些特定元素时，使用迭代器中的remove方法会更节省时间；例如，删除集合中的偶数，常规操作如下：

    int i = 0;
    while (i < list.size()) {
        if (list.get(i) % 2 == 0) {
            list.remove(i);
        } else {
            i++;
        }
    }

因为get和remove都需要遍历集合，因此时间复杂度为，而while循环也需要N次，因此总的时间复杂度为。

使用迭代器中的remove：

    Iterator<Integer> iterator = list.iterator();
    while (iterator.hasNext()) {
        if (iterator.next() % 2 == 0) {
            iterator.remove();
        }
    }

因为要删除的元素正好是迭代器所指向的前一个元素，由于链表的特性将其直接删除只需花费时间，while循环需要N次，那么总的时间复杂度为。

，验证一下：

class TestLinkedList {
    public static void main(String[] args) {
        System.out.printf("输入规模     \t自带remove方法 \t迭代器中remove方法 \n");
        for (int n = 100; n <= 1000000; n *= 10) {
            System.out.print(String.format("N=%7d", n));
            for (int alg = 0; alg <= 1; alg++) {
                getTimingInfo(n, alg);
            }
            System.out.println();
        }
    }

    private static void getTimingInfo(int n, int alg) {
        LinkedList<Integer> list;
        Random random=new Random();
        long startTime = System.currentTimeMillis();
        long totalTime = 0;

        int k;
        for (k = 0; totalTime < 4000; k++) {
            list = new LinkedList<>();
            for (int j = 0; j <n; j++) {
                list.add(random.nextInt(n));
            }
            if (alg == 0) {
                int i = 0;
                while (i < list.size()) {
                    if (list.get(i) % 2 == 0) {
                        list.remove(i);
                    } else {
                        i++;
                    }
                }
            } else if (alg == 1) {
                Iterator<Integer> iterator = list.iterator();

                while (iterator.hasNext()) {
                    if (iterator.next() % 2 == 0) {
                        iterator.remove();
                    }
                }
            }
            totalTime = System.currentTimeMillis() - startTime;
        }

        System.out.print(String.format("\t%12.6f", (totalTime * 1000 / k) / (double) 1000000));
    }
}

从图中可以看出，集合自带的remove方法所消耗的时间确实是以平方级增长的，而迭代器中的remove方法则是以线性增长的。

还需注意的是，在使用迭代器时，不能使用集合中的方法来进行添加和删除的操作，否则会有ConcurrentModificationException异常，看看LinkedList中迭代器部分源码：

    private class ListItr implements ListIterator<E> {
        private Node<E> lastReturned;
        private Node<E> next;
        private int nextIndex;
        private int expectedModCount = modCount;

        public boolean hasNext() {
            return nextIndex < size;
        }

        public E next() {
            checkForComodification();
            if (!hasNext())
                throw new NoSuchElementException();

            lastReturned = next;
            next = next.next;
            nextIndex++;
            return lastReturned.item;
        }
        public void remove() {
            checkForComodification();
            if (lastReturned == null)
                throw new IllegalStateException();

            Node<E> lastNext = lastReturned.next;
            unlink(lastReturned);
            if (next == lastReturned)
                next = lastNext;
            else
                nextIndex--;
            lastReturned = null;
            expectedModCount++;
        }        

假设集合中有三个元素a,b,c，现在使用迭代器遍历完元素a，那么此时next应返回元素a，其中nextIndex=1，而size=3：

若此时在元素b之前插入元素x，那么此时size=4，但是nextIndex依然为1：

那么遍历完b之后nextIndex=2，遍历完c后，应该终止遍历了，但是nextIndex=3，此时nextIndex<size，hasNext进行判断时依然有效，显然，此时调用next将会返回NULL，会造成空指针异常。

若此时删除元素a，那么此时size=2，nextIndex=1：

遍历完元素b后，nextIndex=2与size相等，此时调用hasNext会返回false，但是集合中还有元素c没有被遍历到。

而迭代器中添加和删除操作会对nextIndex以及其他属性进行调整，因此，在使用迭代器时，应使用迭代器中的方法进行添加或删除操作。

4，LinkedList的简单实现

public class MyLinkedList<AnyType> implements Iterable<AnyType> {
    private int theSize;
    private int modCount = 0;
    private Node<AnyType> beginMarker;
    private Node<AnyType> endMarker;

    private static class Node<AnyType> {
        public AnyType data;
        public Node<AnyType> prev;
        public Node<AnyType> next;

        public Node(AnyType data, Node<AnyType> prev, Node<AnyType> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }

    public MyLinkedList() {
        doClear();
    }

    public void clear() {
        doClear();
    }

    private void doClear() {
        beginMarker = new Node<>(null, null, null);
        endMarker = new Node<>(null, beginMarker, null);
        beginMarker.next = endMarker;

        theSize = 0;
        modCount++;
    }

    public int size() {
        return theSize;
    }

    public boolean isEmpty() {
        return size() == 0;
    }

    public boolean add(AnyType element) {
        add(size(), element);
        return true;
    }

    public void add(int index, AnyType element) {
        addBefore(getNode(index, 0, size()), element);
    }

    private void addBefore(Node<AnyType> p, AnyType element) {
        Node<AnyType> newNode = new Node<>(element, p.prev, p);
        newNode.prev.next = newNode;
        p.prev = newNode;
        theSize++;
        modCount++;
    }

    public AnyType get(int index) {
        return getNode(index).data;
    }

    public AnyType set(int index, AnyType newVal) {
        Node<AnyType> p = getNode(index);
        AnyType oldVal = p.data;

        p.data = newVal;
        return oldVal;
    }

    private Node<AnyType> getNode(int index) {
        return getNode(index, 0, size() - 1);
    }

    private Node<AnyType> getNode(int index, int lower, int upper) {
        Node<AnyType> p;
        if (index < lower || index > upper) {
            throw new IndexOutOfBoundsException("getNode index: " + index + "; size: " + size());
        }
        if (index < size() / 2) {
            p = beginMarker.next;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
        } else {
            p = endMarker;
            for (int i = size(); i > index; i--) {
                p = p.prev;
            }
        }
        return p;
    }

    public AnyType remove(int index) {
        return remove(getNode(index));
    }

    private AnyType remove(Node<AnyType> p) {
        p.next.prev = p.prev;
        p.prev.next = p.next;
        theSize--;
        modCount++;

        return p.data;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[ ");

        for (AnyType element : this) {
            sb.append(element + " ");
        }
        sb.append("]");
        return sb.toString();
    }

    @Override
    public Iterator<AnyType> iterator() {
        return new LinkedListIterator();
    }

    private class LinkedListIterator implements Iterator<AnyType> {
        private Node<AnyType> current = beginMarker.next;
        private int expectedModCount = modCount;
        private boolean okToRemove = false;

        @Override
        public boolean hasNext() {
            return current != endMarker;
        }

        @Override
        public AnyType next() {
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            if (!hasNext()) {
                throw new NoSuchElementException();
            }
            AnyType nextElement = current.data;
            current = current.next;
            okToRemove = true;
            return nextElement;
        }

        @Override
        public void remove() {
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            if (!okToRemove) {
                throw new IllegalStateException();
            }

            MyLinkedList.this.remove(current.prev);
            expectedModCount++;
            okToRemove = false;
        }
    }
}

5，比较

时间复杂度	数组	链表
插入删除
随机访问

数组使用连续空间，因此可以很容易计算其中某个元素的地址，实现常数级的随机访问，这也是数组的一个缺点，使用连续空间那么其大小要是固定的，并且一经申明就不可以更改，若申明过大，一是系统可能没有足够的连续内存，二是若用不了这么多空间，会造成浪费；即使ArrayList支持动态扩容，若此时已经存储了1GB的数据，而且没有多余的空间了，就要扩容至1.5GB，并把之前的1GB数据拷贝过来，会非常的耗时。

但是，如果对内存的使用比较苛刻，那么久适合使用数组，因为链表中每个节点都需要消耗额外的空间去存储next和prev。对链表进行频繁的插入和删除时，会频繁的造成内存的申请和释放，容易造成内存碎片，在JAVA中，还会造成频繁的GC。