【數據結構】LinkedList原理及實現總結

時間  2019-11-09
標籤 數據結構 linkedlist 原理 實現 總結 欄目 數據結構 简体版
原文   原文鏈接

　　一樣是List的數據結構，LinkedList是使用了先後指針，指明節點的方式來表示鏈表的，這與以前介紹的ArrayList中使用數組的方式是大相徑庭的。LinkedList中的存儲節點被稱做節點（Node），一個節點的定義以下所示：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)：this

複製代碼 
    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)：spa

複製代碼 
    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)：code

複製代碼 
    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指針也是常常被吐槽是浪費了空間。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程