Pourquoi ArrayDeque est meilleur que LinkedList

J'essaie de comprendre pourquoi ArrayDeque de Java est meilleur que LinkedList de Java car ils implémentent tous les deux l'interface Deque.

Je vois à peine quelqu'un utiliser ArrayDeque dans son code. Si quelqu'un met plus de lumière sur la manière dont ArrayDeque est implémenté, ce serait utile.

Si je le comprends, je serai plus confiant de l'utiliser. Je ne pouvais pas comprendre clairement l'implémentation JDK quant à la façon dont elle gère les références tête et queue.

Les structures liées sont probablement la pire structure à itérer avec un cache manquant sur chaque élément. De plus, ils consomment beaucoup plus de mémoire.

Si vous avez besoin d'ajouter / supprimer les deux extrémités, ArrayDeque est nettement meilleur qu'une liste liée. L'accès aléatoire à chaque élément est également O (1) pour une file d'attente cyclique.

La seule meilleure opération d'une liste chaînée est de supprimer l'élément actuel pendant l'itération.

Je pense que le principal goulot d'étranglement des performances LinkedListréside dans le fait que chaque fois que vous poussez à n'importe quelle extrémité du deque, dans les coulisses, la mise en œuvre alloue un nouveau nœud de liste chaînée, qui implique essentiellement JVM / OS, et c'est cher. De plus, chaque fois que vous sortez de n'importe quelle extrémité, les nœuds internes LinkedListdeviennent éligibles pour le garbage collection et c'est plus de travail en arrière-plan. De plus, étant donné que les nœuds de la liste liée sont alloués ici et là, l'utilisation du cache du processeur ne fournira pas beaucoup d'avantages.

Si cela peut être intéressant, j'ai une preuve que l'ajout (ajout) d'un élément à ArrayListou ArrayDeques'exécute en temps constant amorti; référez-vous à cela .

ArrayDeque est nouveau avec Java 6, c'est pourquoi beaucoup de code (en particulier les projets qui essaient d'être compatibles avec les versions précédentes de Java) ne l'utilisent pas.

C'est «mieux» dans certains cas parce que vous n'allouez pas de nœud pour chaque élément à insérer; au lieu de cela, tous les éléments sont stockés dans un tableau géant, qui est redimensionné s'il est plein.

Tous les gens qui critiquent un LinkedList, pensent à tous les autres gars qui ont utilisé Listen Java utilisent probablement ArrayListet la LinkedListplupart du temps parce qu'ils ont été avant Java 6 et parce que ce sont ceux qui sont enseignés comme un début dans la plupart des livres.

Mais, cela ne veut pas dire, je prendrais aveuglément LinkedList« ou de ArrayDeque» côté s. Si vous voulez savoir, jetez un œil au benchmark ci-dessous réalisé par Brian .

La configuration du test prend en compte:

• Chaque objet de test est une chaîne de 500 caractères. Chaque chaîne est un objet différent en mémoire.
• La taille du tableau de test variera au cours des tests.
• Pour chaque combinaison taille de tableau / mise en œuvre de file d'attente, 100 tests sont exécutés et le temps moyen par test est calculé.
• Chaque test consiste à remplir chaque file d'attente avec tous les objets, puis à les supprimer tous.
• Mesurez le temps en millisecondes.

Résultat du test:

• En dessous de 10 000 éléments, les tests LinkedList et ArrayDeque ont obtenu une moyenne à un niveau inférieur à 1 ms.
• Au fur et à mesure que les ensembles de données s'agrandissent, les différences entre le temps de test moyen d'ArrayDeque et LinkedList s'agrandissent.
• À la taille de test de 9 900 000 éléments, l'approche LinkedList a pris environ 165% de plus que l'approche ArrayDeque.

Graphique:

À emporter:

• Si votre besoin est de stocker 100 ou 200 éléments, cela ne ferait pas beaucoup de différence en utilisant l'une ou l'autre des files d'attente.
• Cependant, si vous développez sur mobile, vous pouvez utiliser un ArrayListou ArrayDequeavec une bonne estimation de la capacité maximale que la liste peut être requise en raison d'une contrainte de mémoire stricte.
• Il existe beaucoup de code, écrit en utilisant une LinkedListbande de roulement tellement prudente au moment de décider d'utiliser un, en ArrayDequeparticulier parce qu'il n'implémente PAS l' Listinterface (je pense que c'est une raison assez grande). Il se peut que votre base de code communique beaucoup avec l'interface List, très probablement et que vous décidez de vous lancer avec un ArrayDeque. L'utiliser pour des implémentations internes pourrait être une bonne idée ...

ArrayDeque et LinkedList implémentent Deque interface mais l'implémentation est différente.

Principales différences:

1. La classe ArrayDeque est l'implémentation de tableau redimensionnable de l' interface Deque et la classe LinkedList est l'implémentation de la liste

2. Les éléments NULL peuvent être ajoutés à LinkedList mais pas dans ArrayDeque

3. ArrayDeque est plus efficace que LinkedList pour l'opération d'ajout et de suppression aux deux extrémités et l'implémentation de LinkedList est efficace pour supprimer l'élément actuel pendant l'itération

4. L' implémentation LinkedList consomme plus de mémoire que ArrayDeque

Donc, si vous n'avez pas à prendre en charge les éléments NULL && à la recherche de moins de mémoire && efficacité d'ajout / suppression d'éléments aux deux extrémités, ArrayDeque est le meilleur

Reportez-vous à la documentation pour plus de détails.

bien que ArrayDeque<E>et LinkedList<E>ont tous deux implémenté Deque<E>Interface, mais ArrayDeque utilise essentiellement un tableau Object E[]pour garder les éléments à l'intérieur de son Object, donc il utilise généralement un index pour localiser les éléments head et tail.

En un mot, cela fonctionne comme Deque (avec toute la méthode Deque), mais utilise la structure de données du tableau. Quant à savoir lequel est le meilleur, cela dépend comment et où vous les utilisez.

Ce n'est pas toujours le cas.

Par exemple, dans le cas ci-dessous linkedlista de meilleures performances que ArrayDequeselon le 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;
    }
}

La complexité temporelle pour ArrayDeque pour accéder à un élément est O (1) et celle pour LinkList est O (N) pour accéder au dernier élément. ArrayDeque n'est pas thread-safe, donc une synchronisation manuelle est nécessaire pour que vous puissiez y accéder via plusieurs threads et qu'ils soient plus rapides.