Hoe de diepte van een binaire zoekboom berekenen

Voor een bepaalde structuur, het aantal knooppunten 1 van de wortel plus het aantal knooppunten in het linker deelboom plus het aantal knooppunten in het rechter deelboom :)

Details, zoals het maken van dat er eigenlijk is een linker of rechter deelboom worden "aan de lezer overgelaten".

Iets zoals dit:

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

En aan de som van de diepten van elk kind te krijgen:

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

Nu voor een hopelijk informatieve uitleg in geval is dit huiswerk. Tellen van het aantal nodes is heel simpel. In de eerste plaats, indien het knooppunt niet een knooppunt ( node == null) retourneert 0. Als het een knooppunt, het telt eerst zijn zelf (het 1), plus het aantal knooppunten in de linker sub-boom plus het aantal knooppunten in haar recht sub-boom. Een andere manier te denken van het is dat je elke knoop te bezoeken via BFS en voeg een aan de telling voor elk knooppunt die u bezoekt.

De som van een diepte gelijk, behalve dat in plaats van slechts een toevoeging voor elk knooppunt het knooppunt voegt de diepte van zijn eigen. En hij weet de diepte van haar zelf, omdat de ouder vertelde het. Elk knooppunt weet dat de diepte van haar kinderen zijn zijn eigen diepte plus één, dus als je de diepte van de linker en rechter kinderen van een knoop te krijgen, je ze vertellen hun diepte is de diepte van de huidige knooppunt plus 1.

En nogmaals, als het knooppunt niet een knooppunt, het heeft geen diepte. Dus als je de som van de diepte van alle kinderen de wortel knooppunt wilt, u passeert in de root-knooppunt en de diepte van de root-knooppunt als volgt:sumDepthOfAllChildren(root, 0)

Recursie is zeer handig, het is gewoon een heel andere manier van denken over dingen en vergt oefening gewend om er te geraken

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

Deze oplossing is zelfs nog eenvoudiger.

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