Complexité des traversées d'arbres binaires
Quelle est la complexité temporelle de la traversée en ordre, post-commande et pré-commande des arbres binaires dans les structures de données ?? Est-ce O(n) ou O (log n) ou O (n ^ 2) ??
Les traversées dans l'ordre, pré-ordre et post-ordre sont des traversées en profondeur d'abord.
Pour un graphe, la complexité d'un premier parcours en profondeur est O (n + m), où n est le nombre de nœuds et m est le nombre d'arêtes.
Puisqu'un arbre binaire est également un graphique, la même chose s'applique ici. La complexité de chacune de ces traversées en profondeur d'abord est O (n + m).
Étant donné que le nombre d'arêtes pouvant provenir d'un nœud est limité à 2 dans le cas d'un arbre binaire, le nombre maximal d'arêtes totales dans un arbre binaire est n-1, où n est le nombre total de nœuds.
La complexité devient alors O (n + n-1), qui est O (n).
O(n), car vous parcourez chaque nœud une fois. Ou plutôt - la quantité de travail que vous faites pour chaque nœud est constante (ne dépend pas du reste des nœuds).
O (n), je dirais. Je fais pour un arbre équilibré, applicable à tous les arbres. En supposant que vous utilisez la récursivité,
T(n) = 2*T(n/2) + 1 ----------> (1)
T (n/2) pour le sous-arbre gauche et T(n/2) pour le sous-arbre droit et '1' pour vérifier le cas de base.
Sur Simplifying (1), vous pouvez prouver que la traversée (en ordre, en précommande ou en post-commande) est d'ordre O (n).
Travesal est O(n) pour toute commande - car vous frappez chaque nœud une fois. La recherche est là où il peut être inférieur à O(n) SI le l'arbre a une sorte de schéma d'organisation (c'est-à-dire un arbre de recherche binaire).
Introduction
Salut
On m'a posé cette question aujourd'hui en classe, et c'est une bonne question! J'expliquerai ici et j'espère que ma réponse plus officielle sera examinée ou corrigée là où elle ne va pas. :)
Réponses précédentes
L'observation par @Assaf est également correcte car la traversée de l'arbre binaire se déplace récursivement pour visiter chaque nœud une fois.
Mais !, comme il s'agit d'un algorithme récursif, vous devez souvent utiliser des méthodes plus avancées pour analyser les performances d'exécution. Lorsqu'il s'agit d'un algorithme séquentiel ou d'un algorithme qui utilise des boucles for, l'utilisation de sommations sera souvent suffisante. Donc, ce qui suit est une explication plus détaillée de cette analyse pour ceux qui sont curieux.
La récurrence
Comme indiqué précédemment,
T (n) = 2 * T (n/2) + 1
où T(n) est le nombre d'opérations exécutées dans votre algorithme de traversée (dans l'ordre, la précommande ou la post-commande ne fait aucune différence).
Explication de la récurrence
Il y a deux T (n) parce que les traversées inorder, preorder et postorder s'appellent toutes sur le nœud enfant gauche et droit. Considérez donc chaque appel récursif comme un T (n) . En d'autres termes, ** gauche T(n/2) + droite T(n/2) = 2 T(n/2) **. Le "1" provient de toute autre opération à temps constant au sein de la fonction, comme l'impression de la valeur du nœud, et cetera. (Il pourrait honnêtement être un 1 ou n'importe quel nombre constant et le temps d'exécution asymptotique calcule toujours à la même valeur. L'explication suit.).
Une analyse
Cette récurrence peut en fait être analysée en utilisant un gros thêta en utilisant le théorème des maîtres. Je vais donc l'appliquer ici.
T (n) = 2 * T (n/2) + constante
où constant est une constante (pourrait être 1 ou toute autre constante).
En utilisant le théorème du maître , nous avons T (n) = a * T (n/b) + f (n) .
Donc, a = 2, b = 2, f(n) = constant puisque f (n) = n ^ c = 1 , il s'ensuit que c = 0 puisque f (n) est une constante.
De là, nous pouvons voir que a = 2 et b ^ c = 2 ^ 0 = 1 . Donc, a> b ^ c ou 2> 2 ^ 0 . Donc, c <logb (a) ou 0 <log2 (2)
De là, nous avons T(n) = BigTheta (n ^ {logb (a)}) = BigTheta (n ^ 1) = BigTheta (n)
Si vous n'êtes pas familier avec BigTheta (n), il est "similaire" (veuillez supporter avec moi :)) à O (n) mais c'est "limite plus stricte" ou approximation plus stricte du temps d'exécution. Donc, BigTheta (n) est à la fois le pire des cas O (n) et dans le meilleur des cas BigOmega (n) au moment de l'exécution.
J'espère que ça aide. Prends soin de toi.
T (n) = 2 T (n/2) + c
T (n/2) = 2T (n/4) + c => T(n) = 4T (n/4) + 2c + c
de même T(n) = 8T (n/8) + 4c + 2c + c
....
....
dernière étape ... T(n) = nT (1) + c (somme des puissances de 2 de 0 à h (hauteur de l'arbre))
donc la complexité est O (2 ^ (h + 1) -1)
mais h = log (n)
donc, O (2n - 1) = O (n)