Warum ist ArrayDeque besser als LinkedList?

Ich versuche zu verstehen, warum Javas ArrayDeque besser ist als Javas LinkedList, da beide die Deque-Schnittstelle implementieren.

Ich sehe kaum jemanden, der ArrayDeque in seinem Code verwendet. Wenn jemand mehr Licht in die Implementierung von ArrayDeque bringt, wäre dies hilfreich.

Wenn ich es verstehe, werde ich sicherer damit umgehen. Ich konnte die JDK-Implementierung hinsichtlich der Art und Weise, wie Head- und Tail-Referenzen verwaltet werden, nicht klar verstehen.

Verknüpfte Strukturen sind möglicherweise die schlechteste Struktur, die mit einem Cache-Fehler für jedes Element iteriert werden kann. Darüber hinaus verbrauchen sie viel mehr Speicher.

Wenn Sie beide Enden hinzufügen / entfernen müssen, ist ArrayDeque deutlich besser als eine verknüpfte Liste. Der Direktzugriff auf jedes Element ist für eine zyklische Warteschlange ebenfalls O (1).

Die einzig bessere Operation einer verknüpften Liste besteht darin, das aktuelle Element während der Iteration zu entfernen.

Ich glaube, dass der größte Leistungsengpass darin LinkedListbesteht, dass die Implementierung hinter den Kulissen immer dann, wenn Sie an ein Ende der Deque drängen, einen neuen Knoten für verknüpfte Listen zuweist, der im Wesentlichen JVM / OS umfasst, und das ist teuer. Wenn Sie von einem beliebigen Ende aus auftauchen, können die internen Knoten von LinkedListfür die Speicherbereinigung verwendet werden, und das ist mehr Arbeit hinter den Kulissen. Da die verknüpften Listenknoten hier und da zugewiesen werden, bietet die Verwendung des CPU-Cache keinen großen Vorteil.

Wenn es von Interesse sein könnte, habe ich einen Beweis dafür, dass das Hinzufügen (Anhängen) eines Elements zu ArrayListoder ArrayDequedie Ausführung in einer amortisierten konstanten Zeit erfolgt; beziehen sich darauf .

ArrayDeque ist neu in Java 6, weshalb viele Codes (insbesondere Projekte, die versuchen, mit früheren Java-Versionen kompatibel zu sein) es nicht verwenden.

In einigen Fällen ist dies "besser", da Sie nicht jedem einzufügenden Element einen Knoten zuweisen. Stattdessen werden alle Elemente in einem riesigen Array gespeichert, dessen Größe geändert wird, wenn es voll wird.

Alle Leute, die a kritisieren LinkedList, denken an jeden anderen Typ, der Listin Java verwendet hat, wahrscheinlich ArrayListund LinkedListmeistens, weil sie vor Java 6 waren und weil dies diejenigen sind, die in den meisten Büchern als Anfang gelehrt werden.

Das heißt aber nicht, dass ich blindlings auf LinkedListder ArrayDequeSeite von oder stehen würde . Wenn Sie es wissen möchten, werfen Sie einen Blick auf den folgenden Benchmark von Brian .

Der Testaufbau berücksichtigt:

• Jedes Testobjekt besteht aus einer Zeichenfolge mit 500 Zeichen. Jeder String ist ein anderes Objekt im Speicher.
• Die Größe des Testarrays wird während der Tests variiert.
• Für jede Kombination aus Arraygröße / Warteschlange und Implementierung werden 100 Tests ausgeführt und die durchschnittliche Zeit pro Test berechnet.
• Jeder Test besteht darin, jede Warteschlange mit allen Objekten zu füllen und dann alle zu entfernen.
• Messen Sie die Zeit in Millisekunden.

Testergebnis:

• Unter 10.000 Elementen wurden sowohl LinkedList- als auch ArrayDeque-Tests auf einer Ebene von unter 1 ms gemittelt.
• Je größer die Datensätze werden, desto größer werden die Unterschiede zwischen der durchschnittlichen Testzeit von ArrayDeque und LinkedList.
• Bei der Testgröße von 9.900.000 Elementen dauerte der LinkedList-Ansatz ~ 165% länger als der ArrayDeque-Ansatz.

Graph:

Wegbringen:

• Wenn in Ihrer Anforderung 100 oder 200 Elemente gespeichert werden, macht die Verwendung einer der Warteschlangen keinen großen Unterschied.
• Wenn Sie jedoch auf Mobilgeräten entwickeln, möchten Sie möglicherweise eine ArrayListoder ArrayDequemit einer guten Schätzung der maximalen Kapazität verwenden, die die Liste aufgrund strenger Speicherbeschränkungen möglicherweise benötigt.
• Es gibt eine Menge Code, der mit einem LinkedListso sorgfältigen Profil geschrieben wurde, wenn Sie sich für die Verwendung von a entschieden haben, ArrayDequeinsbesondere, weil es die ListSchnittstelle NICHT implementiert (ich denke, das ist der Grund, der groß genug ist). Es kann sein, dass Ihre Codebasis höchstwahrscheinlich ausführlich mit der List-Oberfläche kommuniziert und Sie sich entscheiden, mit einem zu springen ArrayDeque. Die Verwendung für interne Implementierungen könnte eine gute Idee sein ...

ArrayDeque und LinkedList implementieren die Deque- Schnittstelle, die Implementierung ist jedoch unterschiedlich.

Hauptunterschiede:

1. Die ArrayDeque- Klasse ist die anpassbare Array-Implementierung der Deque- Schnittstelle und die LinkedList- Klasse ist die Listenimplementierung

2. NULL-Elemente können zu LinkedList hinzugefügt werden, jedoch nicht in ArrayDeque

3. ArrayDeque ist effizienter als die LinkedList für das Hinzufügen und Entfernen an beiden Enden, und die LinkedList-Implementierung ist effizient zum Entfernen des aktuellen Elements während der Iteration

4. Die LinkedList- Implementierung belegt mehr Speicher als die ArrayDeque

Wenn Sie also keine NULL-Elemente unterstützen müssen und weniger Speicher und Effizienz beim Hinzufügen / Entfernen von Elementen an beiden Enden suchen, ist ArrayDeque das Beste

Weitere Informationen finden Sie in der Dokumentation .

Obwohl ArrayDeque<E>und LinkedList<E>beide Deque<E>Interface implementiert haben , verwendet ArrayDeque im Grunde genommen das Object-Array, E[]um die Elemente in seinem Objekt zu belassen. Daher verwendet es im Allgemeinen den Index zum Lokalisieren der Head- und Tail-Elemente.

Mit einem Wort, es funktioniert genau wie Deque (mit allen Deque-Methoden), verwendet jedoch die Datenstruktur des Arrays. Welche besser ist, hängt davon ab, wie und wo Sie sie verwenden.

Das ist nicht immer der Fall.

Zum Beispiel hat im folgenden Fall linkedlisteine bessere Leistung als ArrayDequegemäß Leetcode 103.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> rs=new ArrayList<>();
        if(root==null)
            return rs;
        // 👇 here ,linkedlist works better
        Queue<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        boolean left2right=true;
        while(!queue.isEmpty())
        {
            int size=queue.size();
            LinkedList<Integer> t=new LinkedList<>();
            while(size-->0)
            {
                TreeNode tree=queue.remove();
                if(left2right)  
                    t.add(tree.val);
                else
                    t.addFirst(tree.val);
                if(tree.left!=null)
                {
                    queue.add(tree.left);
                }
                if(tree.right!=null)
                {
                    queue.add(tree.right);
                }
            }
            rs.add(t);
            left2right=!left2right;
        }
        return rs;
    }
}

Die zeitliche Komplexität für ArrayDeque für den Zugriff auf ein Element beträgt O (1) und für LinkList O (N) für den Zugriff auf das letzte Element. ArrayDeque ist nicht threadsicher, daher ist eine manuelle Synchronisierung erforderlich, damit Sie über mehrere Threads darauf zugreifen können und diese schneller sind.