एक द्विआधारी खोज वृक्ष की गहराई की गणना कैसे करें

किसी भी पेड़ के लिए, नोड्स की संख्या जड़ प्लस बाईं सबट्री में नोड्स की संख्या के साथ साथ सही सबट्री में नोड्स की संख्या के लिए 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;
}