Quelles sont les complexités temporelles des différentes structures de données?

J'essaie de lister les complexités temporelles des opérations des structures de données communes comme les tableaux, l'arbre de recherche binaire, le tas, la liste liée, etc. et surtout je fais référence à Java. Ils sont très courants, mais je suppose que certains d'entre nous ne sont pas sûrs à 100% de la réponse exacte. Toute aide, en particulier les références, est grandement appréciée.

Par exemple, pour une liste chaînée unique: la modification d'un élément interne est O (1). Comment peux-tu le faire? Vous DEVEZ rechercher l'élément avant de le modifier. De plus, pour le vecteur, l'ajout d'un élément interne est donné par O (n). Mais pourquoi ne pouvons-nous pas le faire en temps constant amorti en utilisant l'indice? Veuillez me corriger si je manque quelque chose.

Je publie mes conclusions / suppositions comme première réponse.

Tableaux

• Définir, vérifier l' élément à un index particulier: O (1)
• Recherche : O (n) si le tableau n'est pas trié et O (log n) si le tableau est trié et quelque chose comme une recherche binaire est utilisé,
• Comme l'a souligné Aivean , aucune Deleteopération n'est disponible sur les tableaux. Nous pouvons supprimer symboliquement un élément en le définissant sur une valeur spécifique, par exemple -1, 0, etc. en fonction de nos besoins
• De même, Insertpour les tableaux est fondamentalement Setcomme mentionné au début

Liste des tableaux:

• Ajouter : O amorti (1)
• Supprimer : O (n)
• Contient : O (n)
• Taille : O (1)

Liste liée:

• Insertion : O (1) , si fait en tête, O (n) si n'importe où ailleurs puisque nous devons atteindre cette position en parcourant la liste chaînée linéairement.
• Suppression : O (1) , si elle est effectuée en tête, O (n) si ailleurs puisque nous devons atteindre cette position en parcourant la liste chaînée linéairement.
• Recherche : O (n)

Liste à double lien:

• Insertion : O (1) , si fait en tête ou en queue, O (n) si n'importe où ailleurs puisque nous devons atteindre cette position en parcourant la liste chaînée linéairement.
• Suppression : O (1) , si elle est effectuée en tête ou en queue, O (n) si n'importe où ailleurs puisque nous devons atteindre cette position en parcourant la liste chaînée linéairement.
• Recherche : O (n)

Empiler:

• Pousser : O (1)
• Pop : O (1)
• Haut : O (1)
• Recherche (quelque chose comme la recherche, comme opération spéciale): O (n) (je suppose)

File d'attente / Deque / File d'attente circulaire:

• Insérer : O (1)
• Retirer : O (1)
• Taille : O (1)

Arbre de recherche binaire:

• Insérer, supprimer et rechercher : Cas moyen: O (log n) , pire cas: O (n)

Arbre rouge-noir:

• Insérer, supprimer et rechercher : Cas moyen: O (log n) , pire cas: O (log n)

Heap / PriorityQueue (min / max):

• Trouver Min / Trouver Max : O (1)
• Insérer : O (log n)
• Supprimer Min / Supprimer Max : O (log n)
• Extraire Min / Extraire Max : O (log n)
• Rechercher, supprimer (si fourni): O (n) , nous devrons scanner tous les éléments car ils ne sont pas classés comme BST

HashMap / Hashtable / HashSet:

• Insérer / Supprimer : O (1) amorti
• Redimensionner / hachage : O (n)
• Contient : O (1)