Big O des tableaux JavaScript
Les tableaux en JavaScript sont très faciles à modifier en ajoutant et en supprimant des éléments. Cela masque quelque peu le fait que la plupart des tableaux de langues sont de taille fixe et nécessitent un redimensionnement des opérations complexes. Il semble que JavaScript facilite l'écriture de code de tableau peu performant. Cela conduit à la question:
Quelles performances (en termes de grande complexité de temps O) puis-je attendre des implémentations JavaScript en ce qui concerne les performances du tableau?
Je suppose que toutes les implémentations JavaScript raisonnables ont au moins les grands O suivants.
- Accès - O (1)
- Ajout - O (n)
- Prepending - O (n)
- Insertion - O (n)
- Suppression - O (n)
- Échange - O (1)
JavaScript vous permet de pré-remplir un tableau à une certaine taille, en utilisant la syntaxe new Array(length). (Question bonus: crée un tableau de cette manière O(1) ou O(n)) Cela ressemble plus à un tableau conventionnel, et s'il est utilisé en tant que tableau pré-dimensionné, peut permettre l'ajout de O(1). Si une logique de tampon circulaire est ajoutée, vous pouvez obtenir O(1) pré-ajout. Si un tableau à expansion dynamique est utilisé, O (log n) sera le cas moyen pour les deux.
Puis-je m'attendre à de meilleures performances pour certaines choses que mes hypothèses ici? Je ne m'attends pas à ce que quoi que ce soit soit décrit dans les spécifications, mais en pratique, il se pourrait que toutes les implémentations principales utilisent des tableaux optimisés en arrière-plan. Y a-t-il des tableaux à expansion dynamique ou d'autres algorithmes d'amélioration des performances au travail?
P.S.
La raison pour laquelle je me pose cette question est que je recherche des algorithmes de tri, dont la plupart semblent supposer que les opérations d'ajout et de suppression sont des opérations O(1)) lors de la description de leur grand O global.
Contrairement à la plupart des langages, qui implémentent des tableaux avec, enfin, des tableaux, en Javascript Les tableaux sont des objets, et les valeurs sont stockées dans une table de hachage, tout comme les valeurs d'objet normales. En tant que tel:
- Accès - O (1)
- Ajout - Amorti O(1) (parfois le redimensionnement de la table de hachage est requis; généralement, seule l'insertion est requise)
- Prepending - O(n) via
unshift, car il nécessite de réaffecter tous les index - Insertion - Amorti O(1) si la valeur n'existe pas. O(n) si vous souhaitez déplacer les valeurs existantes (par exemple, en utilisant
splice). - Suppression - Amorti O(1) pour supprimer une valeur, O(n) si vous souhaitez réaffecter des indices via
splice). - Échange - O (1)
En général, la définition ou la suppression d'une clé dans un dict est amortie O (1), et il en va de même pour les tableaux, quel que soit l'indice. Toute opération qui nécessite la renumérotation des valeurs existantes est O(n) simplement parce que vous devez mettre à jour toutes les valeurs affectées.