İkili arama ağacının derinliğini hesaplamak için nasıl

Herhangi bir ağaç için düğüm sayısı kökü artı sol alt ağaç düğüm sayısına artı sağ alt ağaç düğüm sayısı için 1'dir :)

Aslında emin orada yapmak gibi Detaylar, olan sol veya sağ alt ağaç, "okuyucuya sol" olan.

Böyle bir şey:

int countChildren(Node node)
{
    if ( node == null )
        return 0;
    return 1 + countChildren(node.getLeft()) + countChildren(node.getRight());
}

Ve her çocuk derinliklerinde toplamını almak için:

int sumDepthOfAllChildren(Node node, int depth)
{
    if ( node == null )
        return 0;  // starting to see a pattern?
    return depth + sumDepthOfAllChildren(node.getLeft(), depth + 1) + 
                   sumDepthOfAllChildren(node.getRight(), depth + 1);
}

Şimdi durumda bir umutla bilgilendirici açıklama için bu ödev olduğunu. Düğümlerin sayısını sayma oldukça basit. Düğüm düğüm (değilse Her şeyden önce node == null) bir düğüm ise 0 döndürür, ilk olarak kendini (sayar 1), artı sol alt ağacındaki düğüm sayısını artı düğümlerin sayısını içinde sağ alt ağacı. Düşününce başka yolu BFS aracılığıyla her düğümün ziyaret ve her ziyaret düğüm için sayımına tane eklemektir.

derinliklerin Toplama yerine her düğüm için sadece bir ekleme haricinde, benzer, düğüm kendi kendini derinlik katar. üst söyledim çünkü onun kendini derinliğini bilir. Her bir düğüm bunun derinliğinde çocuk kendi derinlik artı biri olan birini biliyor, böylece bir düğümün sol ve sağ çocuklarının derinliğini olsun, onların derinlik akım düğümün derinliği artı 1 olduğunu söyle.

Düğüm düğüm değilse Ve yine, hiç derinliğe sahiptir. Eğer tüm kök düğümün çocuklarının derinliğinin toplamını istiyorsanız Yani, şöyle kök düğümü ve kök düğümün derinlemesine pas:sumDepthOfAllChildren(root, 0)

Özyineleme o şeyleri düşünmeye sadece çok farklı bir yolu, oldukça yararlıdır ve buna alışması için pratik ister

public int numberOfNodes()
{
   // This node.
   int result = 1;

   // Plus all the nodes from the left node.
   Node left = getLeft();
   if (left != null)
       result += left.numberOfNodes();

   // Plus all the nodes from the right node.
   Node right = getRight();
   if (right != null)
       result += right.numberOfNodes();

   return result;
}

public int countNodes(Node root)
{  
   // Setup
   // assign to temps to avoid double call accessors. 
   Node left = root.getLeft();
   Node right = root.getRight();
   int count = 1; // count THIS node.

   // count subtrees
   if (left != null) count += countNodes(left);
   if (right != null) count += countNodes(right);

   return count;
}

public class Node {
   private Node left; 
   private Node right;
   public int size() { return 1+ (left==null?0:left.size())+ (right==null?0:right.size());}
}

private static int getNumberOfNodes(Node node) {
    if (node == null) {
        return 0;
    }

    return 1 + getNumberOfNodes(node.left) + getNumberOfNodes(node.right);
}

int depth(treenode *p)
{
   if(p==NULL)return(0);
   if(p->left){h1=depth(p->left);}
   if(p=>right){h2=depth(p->right);}
   return(max(h1,h2)+1);
}

int maxDepth(Node node) {
    if (node == null) {
        return (-1); // an empty tree  has height −1
    } else {
        // compute the depth of each subtree
        int leftDepth = maxDepth(node.left);
        int rightDepth = maxDepth(node.right);
        // use the larger one
        if (leftDepth > rightDepth )
            return (leftDepth + 1);
        else
            return (rightDepth + 1);
    }
}

public int getDepthHelper( TreeNode< T > node ) { 
    int treeHeightLeft; 
    int treeHeightRight; 
    //get height of left subtree 
    if( node.leftNode == null ) 
        treeHeightLeft = 1; 
    else { 
        treeHeightLeft = getDepthHelper( node.leftNode) + 1; 
    } 

    //get height of right subtree 
    if( node.rightNode == null ) 
        treeHeightRight = 1; 
    else { 
        treeHeightRight = getDepthHelper( node.rightNode) + 1; 
    } 
    return Math.max(treeHeightLeft, treeHeightRight); 
}

Bu çözüm daha basittir.

public int getHeight(Node root)
{
    if(root!=null)
        return 1+ Math.max(getHeight(root.leftchild),getHeight(root.rightchild));
    else
        return 0;
}