web-dev-qa-db-fra.com

Calculer la hauteur d'un arbre binaire

J'ai besoin d'aide avec la théorie sur le calcul de la hauteur d'un arbre binaire, généralement la notation.

J'ai lu l'article suivant:

Calculer la hauteur d'un arbre binaire

Et l'un des messages donne la notation suivante:

hauteur (noeud) = max (hauteur (noeud.L), hauteur (noeud.R)) + 1

Supposons que j'ai l'arbre binaire suivant:

     10
   /   \  
  5    30
 / \   /  \ 
4  8  28  42

Est-ce que je calcule donc la valeur maximale sur le noeud de gauche (8) et le noeud maximal sur le droit (42), puis ajoute 1? Je ne comprends pas très bien comment cette notation fonctionne pour calculer la hauteur de l'arbre. 

data-structuresbinary-tree
10
Phorce

Je vais essayer d'expliquer comment fonctionne cet algorithme récursif:

height(10) = max(height(5), height(30)) + 1

height(30) = max(height(28), height(42)) + 1
height(42) = 1 (no children)
height(28) = 1 (no children)

height(5) =  max(height(4), height(8)) + 1
height(4) = 1 (no children)
height(8) = 1 (no children)

Donc, si vous voulez calculer height(10), vous devez développer la récursion vers le bas et remplacer les résultats par la suite.

height(5)  = max(1, 1) + 1
height(30) = max(1, 1) + 1
height(10) = max(2, 2) + 1
height(10) = 3
21
Ondrej Bozek

La hauteur de l'arbre est la longueur du chemin allant de la racine au nœud le plus profond de l'arbre. Voici l'algo le plus court pour le faire

int height(Node root){
   if(root == null )
       return 0;
   return 1+max{height(root.left), height(root.right)};
}
20
roger_that

Connaissez-vous la définition de la hauteur du nœud? Je répondrais comme la distance la plus éloignée d'une feuille accessible (toutes les feuilles ont donc une hauteur de 0) ... essayez maintenant de trouver la hauteur de chaque nœud de bas en haut ... ce serait votre algo .. 

2
sethi

Recherchez le nœud racine, puis recherchez le chemin le plus long que vous pouvez couvrir (signifie le nombre maximal de nœuds que vous pouvez couvrir dans ce chemin), Si vous obtenez ce chemin, puis vérifiez le nombre de branches ou d'arêtes que vous souhaitez. ont couvert, le nombre total de branches couvertes est la hauteur de l'arbre

2
Dip686
#include<stdio.h>
#include<stdlib.h>


/* A binary tree node has data, pointer to left child 
   and a pointer to right child */
struct node 
{
    int data;
    struct node* left;
    struct node* right;
};

/* Compute the "maxDepth" of a tree -- the number of 
    nodes along the longest path from the root node 
    down to the farthest leaf node.*/
int maxDepth(struct node* node) 
{
   if (node==NULL) 
       return 0;
   else
   {
       /* compute the depth of each subtree */
       int lDepth = maxDepth(node->left);
       int rDepth = maxDepth(node->right);

       /* use the larger one */
       if (lDepth > rDepth) 
           return(lDepth+1);
       else return(rDepth+1);
   }
} 

/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode(int data) 
{
    struct node* node = (struct node*)
                                malloc(sizeof(struct node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;

    return(node);
}

int main()
{
    struct node *root = newNode(1);

    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->left->right = newNode(5); 

    printf("Hight of tree is %d", maxDepth(root));

    getchar();
    return 0;
}
0
sankar

Question répétée

En dépit d'être de bonnes introductions à la récursion, je suis un peu surpris par toutes les réponses incorrectes quant à la hauteur d'un arbre binaire, alors j'ai pensé offrir la bonne solution. J'ai fait quelques recherches et cette question trouve une réponse appropriée ici: https://stackoverflow.com/a/2597754/5567854 .

Référence

Selon Wikipedia , "Un arbre composé uniquement d'un nœud racine a une hauteur de 0" et non de 1, comme l'indique l'autre réponse. Par conséquent, avec l'exemple de la question:

     10
   /   \  
  5    30
 / \   /  \ 
4  8  28  42

Si 10 était le nœud racine pour trouver la hauteur de cet arbre, la hauteur est 2, pas 3.

Code correct

Cette solution est l’une des nombreuses solutions possibles en langage C ...

size_t binary_tree_height(const binary_tree_t *tree)
{
    size_t r, l, height = 0;

    if (tree)
    {
        r = tree->right ? binary_tree_height(tree->right) + 1 : 0;
        l = tree->left ? binary_tree_height(tree->left) + 1 : 0;
        height += (r > l ? r : l);
    }
    return (height);
}
0
David John Coleman II

Le plus grand nombre de nœuds possible d'une manière allant du premier nœud (ROOT) à un nœud feuille est appelé la hauteur de l'arbre. La formule pour trouver la hauteur d'un arbre h = i (max) +1, où h est la hauteur et I le niveau max de l'arbre

0
safi