Cum de a calcula adâncimea unui arbore binar de căutare

Pentru orice pom dat, numărul de noduri este 1 pentru rădăcină plus numărul de noduri din subarborele stâng plus numărul de noduri din subarborele din dreapta :)

Detalii, asigurându - vă că de fapt este un subarbore stânga sau la dreapta, sunt „stânga pentru cititor“.

Ceva de genul:

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

Și pentru a obține suma adâncimile fiecărui copil:

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);
}

Acum , pentru o explicație , sperăm , informativ , în cazul în care acest lucru este temele. Numărarea numărul de noduri este destul de simplu. În primul rând, în cazul în care nodul nu este un nod ( node == null) returnează 0. Dacă este un nod, contează mai întâi de sine sa ( 1), plus numărul de noduri din sub-tree stânga plus numărul de noduri în dreptul său sub-tree. Un alt mod de a gândi este să vizitați fiecare nod prin intermediul BFS, și se adaugă unul la contorul pentru fiecare nod pe care le vizitați.

Însumarea adâncimi este similară, cu excepția cazului în loc de a adăuga doar câte unul pentru fiecare nod, nodul adaugă adâncimea de sine sale. Și cunoaște adâncimea de sine sale, deoarece mama sa le-a spus. Fiecare nod știe că adâncimea este de copii sunt este adâncimea proprie, plus unul, astfel încât atunci când obțineți adâncimea stânga și dreapta copiilor unui nod, spune-le adâncimea lor este adâncimea nodului curent plus 1.

Și din nou, în cazul în care nodul nu este un nod, acesta nu are nici o profunzime. Deci, dacă doriți suma adâncimea tuturor copiilor nodul de bază a lui, tu treci în nodul rădăcină și adâncimea nodului root astfel:sumDepthOfAllChildren(root, 0)

Recursivitatea este destul de util, este doar un mod foarte diferit de gândire despre lucruri și ia practică să se obișnuiască cu ea

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); 
}

Această soluție este chiar mai simplu.

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