Πώς να υπολογίσετε το βάθος ενός δυαδικού δένδρου αναζήτησης

Για οποιαδήποτε δέντρο, ο αριθμός των κόμβων είναι 1 για τη ρίζα συν τον αριθμό των κόμβων στο αριστερό υποδένδρο συν τον αριθμό των κόμβων στο δεξιό υποδέντρο :)

Λεπτομέρειες, όπως φροντίζοντας υπάρχει στην πραγματικότητα είναι μια αριστερή ή δεξιά υποδέντρο, τα «αριστερά προς τον αναγνώστη».

Κάτι σαν αυτό:

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

Και για να πάρει το άθροισμα των βάθη του κάθε παιδιού:

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

Τώρα για ένα ελπίζουμε ενημερωτική εξήγηση σε περίπτωση που αυτό είναι εργασία. Μετρώντας τον αριθμό των κόμβων είναι αρκετά απλή. Πρώτα απ 'όλα, αν ο κόμβος δεν είναι ένας κόμβος ( node == null) επιστρέφει 0. Αν είναι ένας κόμβος, που μετράει πρώτα τον εαυτό του (ο 1), καθώς και τον αριθμό των κόμβων στο αριστερό υπο-δέντρο της καθώς και τον αριθμό των κόμβων στο δεξιά υπο-δέντρο του. Ένας άλλος τρόπος για να σκεφτώ είναι να επισκεφθείτε κάθε κόμβο μέσω της BFS, και προσθέστε ένα στο μέτρηση για κάθε κόμβο που επισκέπτεστε.

Η άθροιση των βάθη είναι παρόμοια, εκτός από αντί της προσθήκης μόνο ένα για κάθε κόμβο, ο κόμβος προσθέτει το βάθος του εαυτού του. Και γνωρίζει το βάθος του εαυτού του, διότι η μητρική της, είπε. Κάθε κόμβος γνωρίζει ότι το βάθος της είναι τα παιδιά είναι το δικό βάθος συν ένα, έτσι ώστε όταν παίρνετε το βάθος του αριστερού και του δεξιού παιδιά ενός κόμβου, θα τους πω το βάθος τους είναι το βάθος του τρέχοντος κόμβου συν 1.

Και πάλι, αν ο κόμβος δεν είναι ένας κόμβος, δεν έχει βάθος. Έτσι, εάν θέλετε το ποσό του βάθους όλων των παιδιών του κόμβου ρίζας, περνάτε στον κόμβο ρίζα και το βάθος του κόμβου ρίζας όπως έτσι:sumDepthOfAllChildren(root, 0)

Αναδρομή είναι αρκετά χρήσιμη, είναι απλώς ένα πολύ διαφορετικό τρόπο σκέψης για τα πράγματα και χρειάζεται εξάσκηση για να συνηθίσουν σε αυτό

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

Η λύση αυτή είναι ακόμα πιο απλό.

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