Java數據結構漫談－LinkedList

同樣是List的數據結構，LinkedList是使用了前后指針，指明節點的方式來表示鏈表的，這與之前介紹的ArrayList

http://www.cnblogs.com/yakovchang/p/java_arraylist.html

中使用數組的方式是截然不同的。LinkedList中的存儲節點被稱作節點（Node），一個節點的定義如下所示：

    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

這是LinkedList的一個內部類，不需要使用LinkedList的程序員關心。

LinkedList正是通過next，prev這兩個指針來串聯起整個List的。

注意：Node節點在初始化的時候同時指明了初始化的節點的前后節點是什么，所以在之后的代碼中，往往沒有明顯的寫明新的節點的前后指針指向了哪里。

在LinkedList本身中僅僅記錄了List的開始和結束節點，當然，也記錄了size：

    transient int size = 0;

    transient Node<E> first;

    transient Node<E> last;

在開始節點上添加一個節點，需要先判斷是否為空，如果為空，則直接first和last都指向這個節點，否則就需要把原來的first的prev指向新節點，把新節點作為新的first節點，時間復雜度是o(1)：

    private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

在結束節點上添加一個新節點，需要先判斷是否為空，如果為空，就直接把last和firs都指向這個節點，否則就把原來的last的next指向新節點，把新節點作為新的last節點，時間復雜度是o(1)：

    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

在一個非空節點之前加入一個節點，如果這個非空節點的prev是null，那么說明非空節點是first節點，直接讓first節點指向新節點，否則就讓這個非空節點的next指向新的節點，時間復雜度是o(1)：

    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

刪除一個非空的first節點，是把指向這個節點的指針都移除，同時把first指向他的next節點，如果next節點也為空，說明這個節點是List中的最后一個節點，那么first和last都指向空，時間復雜度是o(1)：

    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        final E element = f.item;
        final Node<E> next = f.next;
        f.item = null;
        f.next = null; // help GC
        first = next;
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

 同樣的，刪除一個非空的last節點，也是把指向這個節點的指針都移除，同時把last指向他的prev節點，如果prev節點為空，說明這個節點是List中的最后一個節點，那么first和last都指向空，時間復雜度是o(1)：

    private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

刪除一個非空節點，則是具有較多的判斷條件，主要是取出來當前節點的prev和next，讓他們之間建立連接，當然還需要判斷是否為空，如果prev是空說明是第一個節點，如果next是空說明是最后一個節點，如果兩者為空，說明List中只有這一個節點，這個操作的時間復雜度是o(1)：

    E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

獲取first，last，刪除first，last，添加first，last，都是基於上述的操作進行的，所以它們的時間復雜度也都是o(1)：

    public E getFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return f.item;
    }

    public E getLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return l.item;
    }

    public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

    public E removeLast() {
        final Node<E> l = last;
        if (l == null)
            throw new NoSuchElementException();
        return unlinkLast(l);
    }

    public void addFirst(E e) {
        linkFirst(e);
    }

    public void addLast(E e) {
        linkLast(e);
    }

以上說的都是時間復雜度較低的操作，但是下面會有時間復雜度較高的操作，這也正是LinkedList被吐槽的地方。

查找一個對象的index是多少，就是通過遍歷對比的方式進行的，其時間復雜度是o(n)：

    public int indexOf(Object o) {
        int index = 0;
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null)
                    return index;
                index++;
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item))
                    return index;
                index++;
            }
        }
        return -1;
    }

而通過index去確定對應的節點，也是使用了便利的辦法，當然，這里采取了一個巧妙的方式是判斷index距離頭部更近，還是尾部更近，然后選擇從哪里開始進行遍歷，其時間復雜度也是o(n)：

    Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

所有使用了上面兩個函數的地方，其時間復雜度都是o(n)。

事實上，由於LinkedList的特殊性，LinkedList本身支持了很多其它的數據結構特性：

實現隊列操作：

    public E peek() {//查看第一個，但不刪除
        final Node<E> f = first;
        return (f == null) ? null : f.item;
    }

    public E element() {//查看第一個，但不刪除
        return getFirst();
    }

    public E poll() {//獲取第一個，並且刪除
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    public E remove() {//獲取第一個並且刪除
        return removeFirst();
    }

    public boolean offer(E e) {//在隊列尾部添加一個
        return add(e);
    }

實現雙向隊列操作：

    public boolean offerFirst(E e) {//在隊列頭部添加一個
        addFirst(e);
        return true;
    }

    public boolean offerLast(E e) {//在隊列尾部添加一個
        addLast(e);
        return true;
    }

    public E peekFirst() {//查看隊列頭部但不刪除
        final Node<E> f = first;
        return (f == null) ? null : f.item;
     }

    public E peekLast() {//查看隊列尾部但不刪除
        final Node<E> l = last;
        return (l == null) ? null : l.item;
    }

    public E pollFirst() {//獲取並且刪除隊列頭部元素
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    public E pollLast() {//獲取並且刪除隊列尾部元素
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

實現棧的操作：

    public E poll() {//查看棧頂但不刪除
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

    public void push(E e) {//壓棧
        addFirst(e);
    }

    public E pop() {//出棧
        return removeFirst();
    }

實現移除第一次發生和最后一次發生：

    public boolean removeFirstOccurrence(Object o) {//移除第一次出現
        return remove(o);
    }


    public boolean removeLastOccurrence(Object o) {//移除最后一次出現
        if (o == null) {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = last; x != null; x = x.prev) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

 

LinkedList是很多數據結構的基礎，在之后的很多數據結構里面還會看到。

LinkedList最大的好處在於頭尾和已知節點的插入和刪除時間復雜度都是o(1)。

但是涉及到先確定位置再操作的情況，則時間復雜度會變為o(n)。

當然，每個節點都需要保留prev和next指針也是經常被吐槽是浪費了空間。