web-dev-qa-db-fra.com

Trouver la hauteur dans l'arbre de recherche binaire

Je me demandais si quelqu'un pourrait m'aider à retravailler cette méthode pour trouver la hauteur d'un arbre de recherche binaire. Jusqu'ici, mon code ressemble à ceci. Cependant, la réponse que je reçois est plus grande que la hauteur réelle de 1. Mais lorsque je supprime le +1 de mes déclarations de retour, elle est inférieure à la hauteur réelle de 1. J'essaie encore de me faire comprendre la récursion ces BST. Toute aide serait très appréciée.

public int findHeight(){
    if(this.isEmpty()){
        return 0;
    }
    else{
        TreeNode<T> node = root;
        return findHeight(node);
    }
}
private int findHeight(TreeNode<T> aNode){
    int heightLeft = 0;
    int heightRight = 0;
    if(aNode.left!=null)
        heightLeft = findHeight(aNode.left);
    if(aNode.right!=null)
        heightRight = findHeight(aNode.right);
    if(heightLeft > heightRight){
        return heightLeft+1;
    }
    else{
        return heightRight+1;
    }
}
binary-tree
49
mike

Le problème réside dans votre cas de base. 

"La hauteur d'un arbre est la longueur du chemin allant de la racine au nœud le plus profond de l'arbre. Un arbre (enraciné) comportant uniquement un nœud (la racine) a une hauteur de zéro." - Wikipédia

S'il n'y a pas de nœud, vous voulez renvoyer -1 et non 0. C'est parce que vous ajoutez 1 à la fin.

Donc s'il n'y a pas de noeud, vous retournez -1 qui annule le +1.

int findHeight(TreeNode<T> aNode) {
    if (aNode == null) {
        return -1;
    }

    int lefth = findHeight(aNode.left);
    int righth = findHeight(aNode.right);

    if (lefth > righth) {
        return lefth + 1;
    } else {
        return righth + 1;
    }
}
97
Corey

La hauteur d'un arbre de recherche binaire est égale à number of layers - 1.

Voir le schéma à http://en.wikipedia.org/wiki/Binary_tree

Votre récursivité est bonne, il suffit donc de soustraire un au niveau racine.

Notez également que vous pouvez nettoyer un peu la fonction en gérant des nœuds nuls: 

int findHeight(node) {
  if (node == null) return 0;
  return 1 + max(findHeight(node.left), findHeight(node.right));
}
32
Stephen
int getHeight(Node node) {
 if (node == null) return -1;

 return 1 + Math.max(getHeight(node.left), getHeight(node.right));
}
17
Harish

OMI, votre code gagnerait à être un peu simplifié. Plutôt que d'essayer de mettre fin à la récursivité lorsqu'un pointeur enfant est null, ne le terminez que lorsque le pointeur current est nul. Cela rend le code un lot plus simple à écrire. Dans le pseudo-code, cela ressemble à ceci:

if (node = null)
    return 0;
else
    left = height(node->left);
    right = height(node->right);
    return 1 + max(left, right);
8
Jerry Coffin

Pour les personnes comme moi qui aiment les solutions en une ligne:

public int getHeight(Node root) {
    return Math.max(root.left != null ? getHeight(root.left) : -1, 
                    root.right != null ? getHeight(root.right) : -1) 
                    + 1;
}
3
lingareddyk

Voici une façon concise et, espérons-le, correcte de l'exprimer:

  private int findHeight(TreeNode<T> aNode){
    if(aNode == null || (aNode.left == null && aNode.right == null))
      return 0;
    return Math.max(findHeight(aNode.left), findHeight(aNode.right)) + 1;
  }

Si le nœud actuel est null, il n'y a pas d'arbre. Si les deux enfants le sont, il n'y a qu'un seul calque, ce qui signifie 0 hauteur. Ceci utilise la définition de hauteur (mentionnée par Stephen) comme Nombre de couches - 1

3
Matthew Flaschen
class Solution{
    public static int getHeight(Node root) {
        int height = -1;

        if (root == null) {
            return height;
        } else {
            height = 1 + Math.max(getHeight(root.left), getHeight(root.right));
        }

        return height;
    }
3
user17711

Ceci n’a pas été testé, mais de toute évidence, il est correct:

 private int findHeight (Treenode aNode) {
 if (aNode.left == null && aNode.right == null) {
 retourne 0; // était 1; apparemment, un nœud sans enfant a une hauteur de 0 .
 } else if (aNode.left == null) {
 retourne 1 + findHeight (aNode.right); 
 } else if (aNode.right == null) {
 return 1 + findHeight (aNode.left); 
 } autre {
 renvoie 1 + max (findHeight (aNode.left), findHeight (aNode.right)); 
 } 
}

Il est souvent plus facile de simplifier votre code que de comprendre pourquoi il est désactivé. Ce code est facile à comprendre: les quatre cas possibles sont clairement traités de manière évidemment correcte:

  • Si les deux arbres de gauche et de droite sont nuls, retourne 1, car un seul nœud a par définition une hauteur de 1.
  • Si les arbres de gauche ou de droite (mais pas les deux!) Sont nuls, renvoyez la hauteur de l'arbre non nul, plus 1 pour tenir compte de la hauteur ajoutée du nœud actuel.
  • Si aucune des deux arborescences n'est nulle, renvoie la hauteur de la sous-arborescence la plus grande, à nouveau plus une pour le nœud actuel.
3
jemfinch
    public void HeightRecursive()
    {
        Console.WriteLine( HeightHelper(root) ); 
    }

    private int HeightHelper(TreeNode node)
    {
        if (node == null)
        {
            return -1;
        }
        else
        {
            return 1 + Math.Max(HeightHelper(node.LeftNode),HeightHelper(node.RightNode));           
        }
    }

Code C # . Incluez ces deux méthodes dans votre classe BST. vous avez besoin de deux méthodes pour calculer la hauteur de l'arbre. HeightHelper le calcule, et HeightRecursive l'imprime dans main (). 

2
Desire

La définition donnée ci-dessus de la hauteur est incorrecte. C'est la définition de la profondeur. 

"La profondeur d'un noeud M dans un arbre est la longueur du chemin allant de la racine de l'arbre à M. La hauteur d'un arbre est égale à un de plus que la profondeur de la Le nœud le plus profond de l’arbre. Tous les nœuds de profondeur d sont au niveau d de l’arbre. La racine est le seul nœud au niveau 0 et sa profondeur est 0. "

Citation : "Introduction pratique à l'analyse de structures de données et à l'algorithme" Edition 3.2 (version Java) Clifford A. Shaffer Département d'informatique Virginia Tech Blacksburg, VA 24061

1
amyers
public int height(){

    if(this.root== null) return 0;

    int leftDepth = nodeDepth(this.root.left, 1);
    int rightDepth = nodeDepth(this.root.right, 1);

    int height = leftDepth > rightDepth? leftDepth: rightDepth;

    return height;
}


private int nodeDepth(Node node, int startValue){

    int nodeDepth = 0;

    if(node.left == null && node.right == null) return startValue;
    else{
        startValue++;
        if(node.left!= null){
            nodeDepth = nodeDepth(node.left, startValue);
        }

        if(node.right!= null){
            nodeDepth = nodeDepth(node.right, startValue);
        }
    }

    return nodeDepth;
}
1
Saikrishna Rao
int height(Node* root) {
        if(root==NULL) return -1;
        return max(height(root->left),height(root->right))+1;
}

Prenez une hauteur maximale des sous-arborescences gauche et droite et ajoutez-y 1. Cela gère également le cas de base (la hauteur de l'arbre avec 1 nœud est 0).

1
Mahendra suthar

Définissez tempHeight en tant que variable statique (initialement 0). 

void statique findHeight (nœud, noeud de comptage) {

    if (node == null) {
        return;
    }
    if ((node.right == null) && (node.left == null)) {
        if (tempHeight < count) {
            tempHeight = count;

        }

    }

    findHeight(node.left, ++count);
    count--; //reduce the height while traversing to a different branch
    findHeight(node.right, ++count);

}
0
Atira_Jak

Je suppose que cette question pourrait signifier deux choses différentes ...

  1. La hauteur est le nombre de nœuds de la branche la plus longue: -

    int calcHeight(node* root){ if(root==NULL) return 0; int l=calcHeight(root->left); int r=calcHeight(root->right); if(l>r) return l+1; else return r+1; }

  2. La hauteur est le nombre total de nœuds dans l'arbre lui-même:

    int calcSize(node* root){ if(root==NULL) return 0; return(calcSize(root->left)+1+calcSize(root->right)); }

0
Mr_Hmp

Voici une solution en Java un peu longue mais qui marche ..

public static int getHeight (Node root){
    int lheight = 0, rheight = 0;
    if(root==null) {
        return 0;
    }
    else {
        if(root.left != null) {
            lheight = 1 + getHeight(root.left);
            System.out.println("lheight" + " " + lheight);
        }
        if (root.right != null) {
            rheight = 1+ getHeight(root.right);
            System.out.println("rheight" + " " + rheight);
        }
        if(root != null && root.left == null && root.right == null) {
            lheight += 1; 
            rheight += 1;
        }

    }
    return Math.max(lheight, rheight);
    }
0
warl0ck

Voici une solution en C #

    private static int height_Tree(Node root)
    {
        if (root == null)
        {
            return 0;
        }

        int left = 1 + height_Tree(root.left);
        int right = 1 + height_Tree(root.right);

        return Math.Max(left, right);
    }
0
Vbp
 int getHeight(Node* root)
 {
   if(root == NULL) return -1;
   else             return max(getHeight(root->left), getHeight(root->right)) + 1;
 }
0
rashedcs

entrez la description de l'image ici

Selon "Introduction to Algorithms" de Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest et Clifford Stein, voici la définition de la hauteur de l'arbre:

La hauteur d'un nœud dans un arbre est le nombre d'arêtes sur le plus long chemin descendant simple du nœud à une feuille, et la hauteur d'un arbre est la hauteur de sa racine. La hauteur d'un arbre est également égale à la plus grande profondeur de tout nœud de l'arbre.

Voici ma solution Ruby. La plupart des gens ont oublié la hauteur de l'arbre vide ou de l'unique noeud dans leur implémentation.

def height(node, current_height)
  return current_height if node.nil? || (node.left.nil? && node.right.nil?)
  return [height(node.left, current_height + 1), height(node.right, current_height + 1)].max if node.left && node.right
  return height(node.left, current_height + 1) if node.left
  return height(node.right, current_height + 1)
end
0
saikat sarkar
public int getHeight(Node node)
{
    if(node == null)
        return 0;

    int left_val = getHeight(node.left);
    int right_val = getHeight(node.right);
    if(left_val > right_val)
        return left_val+1;
    else
        return right_val+1;
}
0
avishek gurung

// fonction pour trouver la hauteur de BST

int height(Node* root) {
    if(root == NULL){
        return -1;
    }

    int sum=0;
    int rheight = height(root->right);
    int lheight = height(root->left);

    if(lheight>rheight){
        sum = lheight +1;
    }
    if(rheight > lheight){
        sum = rheight + 1;
    }

    return sum;
}
0
Kizito Nwaka

Pour toute autre personne qui lit ceci !!!!

HEIGHT est défini comme le nombre de nœuds dans le plus long chemin du nœud racine à un nœud feuille. Par conséquent: un arbre avec seulement un nœud racine a une hauteur de 1 et non 0.

Le NIVEAU d'un nœud donné est la distance de la racine plus 1. Par conséquent: la racine est au niveau 1, ses nœuds enfants sont au niveau 2 et ainsi de suite.

(Information fournie par Data Structures: Abstraction et conception en utilisant Java, 2e édition, par Elliot B. Koffman et Paul A. T. Wolfgang) - Livre utilisé dans le cours sur les structures de données que je suis en train de suivre à la Columbus State University.

0
Aalyiah7492
int maxDepth(BinaryTreeNode root) {
    if(root == null || (root.left == null && root.right == null)) {
       return 0;
    }

    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}
0
Phat Nguyen