Hauteur d'un arbre binaire
Considérez le code suivant:
public int heightOfBinaryTree(Node node)
{
if (node == null)
{
return 0;
}
else
{
return 1 +
Math.max(heightOfBinaryTree(node.left),
heightOfBinaryTree(node.right));
}
}
Je veux connaître le raisonnement logique derrière ce code. Comment les gens ont-ils pensé à ça? Certains ont-ils une preuve inductive?
De plus, je pensais juste faire un BFS avec la racine de l'arbre binaire comme argument pour obtenir la hauteur de l'arbre binaire. L'approche précédente est-elle meilleure que la mienne? Pourquoi?
if (node == null)
{
return 0;
}
Les enfants des nœuds feuilles sont null. Par conséquent, cela signifie qu'une fois que nous avons dépassé les feuilles, il n'y a plus de nœuds.
Si nous ne dépassons pas les nœuds feuilles, nous devons calculer la hauteur et ce code le fait récursivement.
return 1 +
Le nœud actuel ajoute une hauteur de 1 à la hauteur du sous-arbre en cours de calcul.
Math.max(heightOfBinaryTree(node.left),
heightOfBinaryTree(node.right));
Nous calculons récursivement la hauteur du sous-arbre gauche (node.left) Et du sous-arbre droit (node.right). Puisque nous calculons la profondeur maximale, nous prenons le maximum de ces deux profondeurs.
J'ai montré ci-dessus que la fonction récursive est correcte. Ainsi, l'appel de la fonction sur le nœud parent calculera la profondeur de l'arbre entier.
Voici une représentation graphique de la hauteur d'un arbre de ce document . h est la hauteur de l'arbre, hl et hr sont les hauteurs des sous-arbres gauche et droit respectivement.
De plus, j'ai pensé à faire juste un BFS avec la racine de l'arbre binaire comme argument pour obtenir la hauteur de l'arbre binaire. L'approche précédente est-elle meilleure que la mienne? Pourquoi?
Le code que vous avez fourni est une forme de DFS. Étant donné que vous devez traiter tous les nœuds pour trouver la hauteur de l'arborescence, il n'y aura pas de différence d'exécution entre DFS et BFS, bien que BFS utilisera la mémoire O(N) tandis que DFS utilisera O(logN) Mémoire. BFS est également légèrement plus complexe à coder, car il nécessite une file d'attente tandis que DFS utilise la pile récursive "intégrée".
La logique derrière ce code est:
puisqu'un nœud aura deux enfants, la hauteur de l'arbre sera au maximum des hauteurs d'arbre dont les racines sont l'enfant gauche et l'enfant droit, et bien sûr +1 pour la marche vers les enfants.
Comme vous pouvez le voir, la description ci-dessus est récursive tout comme le code.
BFS devrait également le faire, mais ce serait une exagération en termes d'implémentation et de complexité d'espace/temps.
Il y a un mot à dire, les fonctions récursives sont difficiles à comprendre, mais sont très élégantes à mettre en œuvre.
La hauteur d'un arbre est la longueur du plus long chemin descendant depuis sa racine. Cette fonction est une manière récursive de compter les niveaux d'un arbre binaire. Il incrémente simplement les compteurs au fur et à mesure qu'il descend dans l'arbre, renvoyant le compteur maximum (le compteur sur le nœud le plus bas).
J'espère avoir aidé.
C'est une fonction récursive. Cela signifie que la hauteur d'un arbre est de 1 + la hauteur de sa branche la plus haute.
BFS est-il une première recherche étendue? Je ne sais pas quelle différence il y aurait dans l'efficacité, mais j'aime la simplicité de la fonction récursive.