Hvordan beregne dybden av et binært søketre

For et gitt tre, er antallet noder 1 til roten pluss antall noder i den venstre subtre pluss antall noder i den høyre subtre :)

Detaljer, som gjør at det faktisk er en venstre eller høyre subtre, blir "overlatt til leseren".

Noe sånt som dette:

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

Og for å få summen av dypet av alle barn:

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

Nå for en forhåpentligvis informativ forklaring i tilfelle dette er lekser. Telle antall noder er ganske enkel. Først av alt, hvis noden er ikke en node ( node == null) returnerer den 0. Hvis det er en node, den første teller dens selv (det 1), pluss antall noder i dens venstre sub-treet pluss antall noder i sin rett sub-treet. En annen måte å tenke på det er du besøke hver node via BFS, og legge en til tellingen for hver node du besøker.

Summering av dybder er like, bortsett fra i stedet for å tilsette bare en for hver node, legger noden dybden av sin egen. Og det vet dybden av sin egen fordi den overordnede fortalte det. Hver node vet at dybden av det er barn er det egen dybde pluss én, så når du får dybden på venstre og høyre barn av en node, fortelle dem deres dybde er gjeldende node dybde pluss en.

Og igjen, hvis noden er ikke en node, det har ingen dybde. Så hvis du vil summen av dybden i alle rotnoden barn, passerer du i rotnoden og rotnoden dybde slik:sumDepthOfAllChildren(root, 0)

Rekursjon er ganske nyttig, det er bare en helt annen måte å tenke på ting og tar praksis å bli vant til det

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

Denne løsningen er enda mer enklere.

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