blocks|key|1068174|text|下面是一种简明而有希望正确的表达方式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068175|++private+int+findHeight(TreeNode<T>+aNode){
++++if(aNode+==+null+%7C%7C+(aNode.left+==+null+&&+aNode.right+==+null))
++++++return+0;
++++return+Math.max(findHeight(aNode.left),+findHeight(aNode.right))+%2B+1;
++}|code-block|syntax|javascript|1068176|如果当前节点为空，则没有树。如果两个子对象都是，则只有一个层，这意味着高度为0。这使用了高度的定义(Stephen提到的)作为层数-1|1068177|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here's a concise and hopefully correct way to express it:

<pre><code> private int findHeight(TreeNode&lt;T&gt; aNode){
 if(aNode == null || (aNode.left == null &amp;&amp; aNode.right == null))
 return 0;
 return Math.max(findHeight(aNode.left), findHeight(aNode.right)) + 1;
 }
</code></pre>

If the current node is null, there's no tree. If both children are, there's a single layer, which means 0 height. This uses the definition of height (mentioned by Stephen) as # of layers - 1

blocks|key|1068229|text|二叉树的高度等于number+of+layers+-+1。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1068230|请参阅http://en.wikipedia.org/wiki/Binary_tree上的图表|1068231|您的递归很好，所以只需在根级别减去1即可。|1068232|另请注意，您可以通过处理空节点来清理函数：|1068233|int+findHeight(node)+{
++if+(node+==+null)+return+0;
++return+1+%2B+max(findHeight(node.left),+findHeight(node.right));
}|code-block|syntax|javascript|1068234|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Binary_tree^0|8|K|0|3|14|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|I|5|6|7|15|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|16|8|@]|D|@]|E|$]]|$1|L|3|M|5|N|7|17|8|@]|D|@]|E|$O|P]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

The height of a binary search tree is equal to <code>number of layers - 1</code>.

See the diagram at <a href="http://en.wikipedia.org/wiki/Binary_tree" rel="noreferrer">http://en.wikipedia.org/wiki/Binary_tree</a>

Your recursion is good, so just subtract one at the root level.

Also note, you can clean up the function a bit by handling null nodes: 

<pre><code>int findHeight(node) {
 if (node == null) return 0;
 return 1 + max(findHeight(node.left), findHeight(node.right));
}
</code></pre>

blocks|key|1068296|text|问题出在你的基本情况上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068297|“树的高度是从根到树中最深节点的路径长度。只有一个节点(根)的(根)树的高度为零。”-+Wikipedia|offset|length|1068298|如果没有节点，您希望返回-1而不是0。这是因为您在末尾添加了1。|1068299|因此，如果没有节点，则返回-1，这将取消%2B1。|1068300|int+findHeight(TreeNode<T>+aNode)+{
++++if+(aNode+==+null)+{
++++++++return+-1;
++++}

++++int+lefth+=+findHeight(aNode.left);
++++int+righth+=+findHeight(aNode.right);

++++if+(lefth+>+righth)+{
++++++++return+lefth+%2B+1;
++++}+else+{
++++++++return+righth+%2B+1;
++++}
}|code-block|syntax|javascript|1068301|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Binary_tree^0|0|18|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|12|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|13|8|@]|9|@]|A|$M|N]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

The problem lies in your base case. 

"The height of a tree is the length of the path from the root to the deepest node in the tree. A (rooted) tree with only a node (the root) has a height of zero." - <a href="http://en.wikipedia.org/wiki/Binary_tree" rel="noreferrer">Wikipedia</a> 

If there is no node, you want to return -1 not 0. This is because you are adding 1 at the end.

So if there isn't a node, you return -1 which cancels out the +1.

<pre><code>int findHeight(TreeNode&lt;T&gt; aNode) {
 if (aNode == null) {
 return -1;
 }

 int lefth = findHeight(aNode.left);
 int righth = findHeight(aNode.right);

 if (lefth &gt; righth) {
 return lefth + 1;
 } else {
 return righth + 1;
 }
}
</code></pre>

blocks|key|1068364|text|++++public+void+HeightRecursive()
++++{
++++++++Console.WriteLine(+HeightHelper(root)+);+
++++}

++++private+int+HeightHelper(TreeNode+node)
++++{
++++++++if+(node+==+null)
++++++++{
++++++++++++return+-1;
++++++++}
++++++++else
++++++++{
++++++++++++return+1+%2B+Math.Max(HeightHelper(node.LeftNode),HeightHelper(node.RightNode));+++++++++++
++++++++}
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1068365|C#代码。在您的BST类中包含这两个方法。你需要两种方法来计算树的高度。HeightHelper计算它，然后在HeightRecursive+()中打印它。|unstyled|1068366|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code> public void HeightRecursive()
 {
 Console.WriteLine( HeightHelper(root) ); 
 }

 private int HeightHelper(TreeNode node)
 {
 if (node == null)
 {
 return -1;
 }
 else
 {
 return 1 + Math.Max(HeightHelper(node.LeftNode),HeightHelper(node.RightNode)); 
 }
 }
</code></pre>

C# code.
Include these two methods in your BST class. you need two method to calculate height of tree. HeightHelper calculate it, &amp; HeightRecursive print it in main().

blocks|key|1283088|text|对于任何其他阅读本文的人！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283089|高度被定义为从根节点到叶节点的最长路径中的节点数。因此:只有一个根节点的树的高度是1而不是0。|1283090|给定节点的级别是距根节点的距离加1。因此:根节点位于级别1，其子节点位于级别2，依此类推。|1283091|(信息由数据结构提供:使用Java的抽象和设计，第二版，作者Elliot+B.+Koffman和Paul+A.+T.+Wolfgang)+-我目前正在哥伦布州立大学学习数据结构课程中使用的书。|1283092|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

For anyone else that reads this!!!!

HEIGHT is defined as the number of nodes in the longest path from the root node to a leaf node. Therefore: a tree with only a root node has a height of 1 and not 0.

The LEVEL of a given node is the distance from the root plus 1. Therefore: The root is on level 1, its child nodes are on level 2 and so on.

(Information courtesy of Data Structures: Abstraction and Design Using Java, 2nd Edition, by Elliot B. Koffman &amp; Paul A. T. Wolfgang) - Book used in Data Structures Course I am currently taking at Columbus State University.

blocks|key|1283096|text|public+int+getHeight(Node+node)
{
++++if(node+==+null)
++++++++return+0;

++++int+left_val+=+getHeight(node.left);
++++int+right_val+=+getHeight(node.right);
++++if(left_val+>+right_val)
++++++++return+left_val%2B1;
++++else
++++++++return+right_val%2B1;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283097|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public int getHeight(Node node)
{
 if(node == null)
 return 0;

 int left_val = getHeight(node.left);
 int right_val = getHeight(node.right);
 if(left_val &gt; right_val)
 return left_val+1;
 else
 return right_val+1;
}
</code></pre>

blocks|key|1068483|text|下面是C#的一个解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068484|++++private+static+int+heightOfTree(Node+root)
++++{
++++++++if+(root+==+null)
++++++++{
++++++++++++return+0;
++++++++}

++++++++int+left+=+1+%2B+heightOfTree(root.left);
++++++++int+right+=+1+%2B+heightOfTree(root.right);

++++++++return+Math.Max(left,+right);
++++}|code-block|syntax|javascript|1068485|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a solution in C#

<pre><code> private static int heightOfTree(Node root)
 {
 if (root == null)
 {
 return 0;
 }

 int left = 1 + heightOfTree(root.left);
 int right = 1 + heightOfTree(root.right);

 return Math.Max(left, right);
 }
</code></pre>

blocks|key|1283181|text|int+getHeight(Node+node)+{
+if+(node+==+null)+return+-1;

+return+1+%2B+Math.max(getHeight(node.left),+getHeight(node.right));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283182|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>int getHeight(Node node) {
 if (node == null) return -1;

 return 1 + Math.max(getHeight(node.left), getHeight(node.right));
}
</code></pre>

blocks|key|1283227|text|将tempHeight设置为静态变量(初始为0)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283228|静态空findHeight(节点节点，整型计数){|1283229|++++if+(node+==+null)+{
++++++++return;
++++}
++++if+((node.right+==+null)+&&+(node.left+==+null))+{
++++++++if+(tempHeight+<+count)+{
++++++++++++tempHeight+=+count;

++++++++}

++++}

++++findHeight(node.left,+%2B%2Bcount);
++++count--;+//reduce+the+height+while+traversing+to+a+different+branch
++++findHeight(node.right,+%2B%2Bcount);

}|code-block|syntax|javascript|1283230|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Set a tempHeight as a static variable(initially 0). 

static void findHeight(Node node, int count) {

<pre><code> if (node == null) {
 return;
 }
 if ((node.right == null) &amp;&amp; (node.left == null)) {
 if (tempHeight &lt; count) {
 tempHeight = count;

 }

 }

 findHeight(node.left, ++count);
 count--; //reduce the height while traversing to a different branch
 findHeight(node.right, ++count);

}
</code></pre>

blocks|key|1068605|text|这是一个用Java编写的解决方案，虽然有点冗长，但很有效。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1068606|public+static+int+getHeight+(Node+root){
++++int+lheight+=+0,+rheight+=+0;
++++if(root==null)+{
++++++++return+0;
++++}
++++else+{
++++++++if(root.left+!=+null)+{
++++++++++++lheight+=+1+%2B+getHeight(root.left);
++++++++++++System.out.println("lheight"+%2B+"+"+%2B+lheight);
++++++++}
++++++++if+(root.right+!=+null)+{
++++++++++++rheight+=+1%2B+getHeight(root.right);
++++++++++++System.out.println("rheight"+%2B+"+"+%2B+rheight);
++++++++}
++++++++if(root+!=+null+&&+root.left+==+null+&&+root.right+==+null)+{
++++++++++++lheight+%2B=+1;+
++++++++++++rheight+%2B=+1;
++++++++}

++++}
++++return+Math.max(lheight,+rheight);
++++}|code-block|syntax|javascript|1068607|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here is a solution in Java a bit lengthy but works..

<pre><code>public static int getHeight (Node root){
 int lheight = 0, rheight = 0;
 if(root==null) {
 return 0;
 }
 else {
 if(root.left != null) {
 lheight = 1 + getHeight(root.left);
 System.out.println("lheight" + " " + lheight);
 }
 if (root.right != null) {
 rheight = 1+ getHeight(root.right);
 System.out.println("rheight" + " " + rheight);
 }
 if(root != null &amp;&amp; root.left == null &amp;&amp; root.right == null) {
 lheight += 1; 
 rheight += 1;
 }

 }
 return Math.max(lheight, rheight);
 }
</code></pre>

blocks|key|1283292|text|class+Solution{
++++public+static+int+getHeight(Node+root)+{
++++++++int+height+=+-1;

++++++++if+(root+==+null)+{
++++++++++++return+height;
++++++++}+else+{
++++++++++++height+=+1+%2B+Math.max(getHeight(root.left),+getHeight(root.right));
++++++++}

++++++++return+height;
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283293|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>class Solution{
 public static int getHeight(Node root) {
 int height = -1;

 if (root == null) {
 return height;
 } else {
 height = 1 + Math.max(getHeight(root.left), getHeight(root.right));
 }

 return height;
 }
</code></pre>

blocks|key|1283304|text|+int+getHeight(Node*+root)
+{
+++if(root+==+NULL)+return+-1;
+++else+++++++++++++return+max(getHeight(root->left),+getHeight(root->right))+%2B+1;
+}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283305|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code> int getHeight(Node* root)
 {
 if(root == NULL) return -1;
 else return max(getHeight(root-&gt;left), getHeight(root-&gt;right)) + 1;
 }
</code></pre>

blocks|key|1283333|text|public+int+height(){

++++if(this.root==+null)+return+0;

++++int+leftDepth+=+nodeDepth(this.root.left,+1);
++++int+rightDepth+=+nodeDepth(this.root.right,+1);

++++int+height+=+leftDepth+>+rightDepth?+leftDepth:+rightDepth;

++++return+height;
}


private+int+nodeDepth(Node+node,+int+startValue){

++++int+nodeDepth+=+0;

++++if(node.left+==+null+&&+node.right+==+null)+return+startValue;
++++else{
++++++++startValue%2B%2B;
++++++++if(node.left!=+null){
++++++++++++nodeDepth+=+nodeDepth(node.left,+startValue);
++++++++}

++++++++if(node.right!=+null){
++++++++++++nodeDepth+=+nodeDepth(node.right,+startValue);
++++++++}
++++}

++++return+nodeDepth;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283334|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>public int height(){

 if(this.root== null) return 0;

 int leftDepth = nodeDepth(this.root.left, 1);
 int rightDepth = nodeDepth(this.root.right, 1);

 int height = leftDepth &gt; rightDepth? leftDepth: rightDepth;

 return height;
}


private int nodeDepth(Node node, int startValue){

 int nodeDepth = 0;

 if(node.left == null &amp;&amp; node.right == null) return startValue;
 else{
 startValue++;
 if(node.left!= null){
 nodeDepth = nodeDepth(node.left, startValue);
 }

 if(node.right!= null){
 nodeDepth = nodeDepth(node.right, startValue);
 }
 }

 return nodeDepth;
}
</code></pre>

blocks|key|1283393|text|对于像我这样喜欢单行解决方案的人：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283394|public+int+getHeight(Node+root)+{
++++return+Math.max(root.left+!=+null+?+getHeight(root.left)+:+-1,+
++++++++++++++++++++root.right+!=+null+?+getHeight(root.right)+:+-1)+
++++++++++++++++++++%2B+1;
}|code-block|syntax|javascript|1283395|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For people like me who like one line solutions:

<pre><code>public int getHeight(Node root) {
 return Math.max(root.left != null ? getHeight(root.left) : -1, 
 root.right != null ? getHeight(root.right) : -1) 
 + 1;
}
</code></pre>

blocks|key|1283413|text|//查找BST高度函数|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283414|int+height(Node*+root)+{
++++if(root+==+NULL){
++++++++return+-1;
++++}

++++int+sum=0;
++++int+rheight+=+height(root->right);
++++int+lheight+=+height(root->left);

++++if(lheight>rheight){
++++++++sum+=+lheight+%2B1;
++++}
++++if(rheight+>+lheight){
++++++++sum+=+rheight+%2B+1;
++++}

++++return+sum;
}|code-block|syntax|javascript|1283415|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

//function to find height of BST

<pre><code>int height(Node* root) {
 if(root == NULL){
 return -1;
 }

 int sum=0;
 int rheight = height(root-&gt;right);
 int lheight = height(root-&gt;left);

 if(lheight&gt;rheight){
 sum = lheight +1;
 }
 if(rheight &gt; lheight){
 sum = rheight + 1;
 }

 return sum;
}
</code></pre>

blocks|key|1068809|text|int+height(Node*+root)+{
++++++++if(root==NULL)+return+-1;
++++++++return+max(height(root->left),height(root->right))%2B1;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1068810|从左侧和右侧的子树中获取最大高度，并将1添加到it.This中也可以处理基本情况(具有1个节点的树的高度为0)。|unstyled|1068811|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>int height(Node* root) {
 if(root==NULL) return -1;
 return max(height(root-&gt;left),height(root-&gt;right))+1;
}
</code></pre>

Take of maximum height from left and right subtree and add 1 to it.This also handles the base case(height of Tree with 1 node is 0).

blocks|key|1283464|text|int+maxDepth(BinaryTreeNode+root)+{
++++if(root+==+null+%7C%7C+(root.left+==+null+&&+root.right+==+null))+{
+++++++return+0;
++++}

++++return+1+%2B+Math.max(maxDepth(root.left),+maxDepth(root.right));
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283465|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>int maxDepth(BinaryTreeNode root) {
 if(root == null || (root.left == null &amp;&amp; root.right == null)) {
 return 0;
 }

 return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}
</code></pre>

blocks|key|1068880|text|我自己也很努力，试图找到一些优雅的东西，仍然可以得到正确的值。这是我使用Swift想出的方法。请注意，height是一个计算变量，从技术上讲不是一个函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1068881|class+Node<T:+Comparable>:+NSObject
{
++++var+left:+Node<T>?+=+nil
++++var+right:+Node<T>?+=+nil
+
++++var+isLeaf:+Bool+{+left+==+nil+&&+right+==+nil+}

++++var+height:+Int+{
++++++++if+isLeaf+{+return+0+}
++++++++return+1+%2B+max(left?.height+??+0,+right?.height+??+0)
++++}
}|code-block|syntax|javascript|1068882|该节点定义还有更多内容，但是您可以看到left和right变量(可能为nil)以及一个isLeaf变量，该变量在left和right都为nil时为nil。可能不是最有效的，但我相信它会产生正确的结果。|1068883|BST定义还有一个计算出的height变量，当树为空时返回-1。|1068884|class+BST<T:+Comparable>:+NSObject
{
++++var+root:+Node<T>?
++++var+height:+Int+{+root+!=+nil+?+root!.height+:+-1+}
}|1068885|entityMap^0|1F|6|0|0|J|4|O|5|17|6|1K|4|1P|5|1W|3|21|3|0|D|6|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|H|7|1E|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]]|R|$]]

I struggled with this myself trying to find something elegant that still resulted in the correct value. Here's what I came up with using Swift. Note that <code>height</code> is a computed variable and technically not a function.
<pre><code>class Node&lt;T: Comparable&gt;: NSObject
{
 var left: Node&lt;T&gt;? = nil
 var right: Node&lt;T&gt;? = nil
 
 var isLeaf: Bool { left == nil &amp;&amp; right == nil }

 var height: Int {
 if isLeaf { return 0 }
 return 1 + max(left?.height ?? 0, right?.height ?? 0)
 }
}
</code></pre>
There's more to this Node definition but you can see the <code>left</code> and <code>right</code> variables (possibly nil) and an <code>isLeaf</code> var that is <code>true</code> when both <code>left</code> and <code>right</code> are <code>nil</code>. Might not be the most efficient but I believe it yields the correct result.
The BST definition also has a computed <code>height</code> variable and returns -1 when the tree is empty.
<pre><code>class BST&lt;T: Comparable&gt;: NSObject
{
 var root: Node&lt;T&gt;?
 var height: Int { root != nil ? root!.height : -1 }
}
</code></pre>

blocks|key|1283577|text|HackerRank+Day+22:+Finding+height+in+Binary+Search+Tree,+in+C#.

+++++static+int+getHeight(Node+root)
++++++++{
++++++++++++//Write+your+code+here
++++++++++++int+countr+=+0,countl=0;
++++++++++++Node+Leftsubtree=root.left;
++++++++++++Node+rightsubtree+=+root.right;
++++++++++++int+data=root.data;
+++++++++++++if(root==null+%7C%7C(root.left+==+null+&&+root.right+==+null))
++++++++++++{
++++++++++++++++return+0;
++++++++++++}
+++++++++++++else
++++++++++++{
++++++++++++++++while+(Leftsubtree+!=+null)
++++++++++++++++{
++++++++++++++++++++++++if(Leftsubtree.data<data)
++++++++++++++++++++++++{
++++++++++++++++++++++++Leftsubtree+=+Leftsubtree.left==null?Leftsubtree.right:Leftsubtree.left;
++++++++++++++++++++++++countl%2B%2B;
++++++++++++++++++++++++}
++++++++++++++++}
++++++++++++++++while+(rightsubtree+!=+null)
++++++++++++++++{
++++++++++++++++++++if+(rightsubtree.data+>+data)
++++++++++++++++++++{
++++++++++++++++++++++++rightsubtree+=+rightsubtree.right+==+null+?+rightsubtree.left+:+rightsubtree.right;
++++++++++++++++++++++++countr%2B%2B;
++++++++++++++++++++}
++++
++++++++++++++++}
++++++++++++}
++++
++++++++++++return+countr+>=+countl+?+countr+:+countl;
++++
++++
++++++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283578|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>HackerRank Day 22: Finding height in Binary Search Tree, in C#.

 static int getHeight(Node root)
 {
 //Write your code here
 int countr = 0,countl=0;
 Node Leftsubtree=root.left;
 Node rightsubtree = root.right;
 int data=root.data;
 if(root==null ||(root.left == null &amp;&amp; root.right == null))
 {
 return 0;
 }
 else
 {
 while (Leftsubtree != null)
 {
 if(Leftsubtree.data&lt;data)
 {
 Leftsubtree = Leftsubtree.left==null?Leftsubtree.right:Leftsubtree.left;
 countl++;
 }
 }
 while (rightsubtree != null)
 {
 if (rightsubtree.data &gt; data)
 {
 rightsubtree = rightsubtree.right == null ? rightsubtree.left : rightsubtree.right;
 countr++;
 }
 
 }
 }
 
 return countr &gt;= countl ? countr : countl;
 
 
 }
</code></pre>

I was wondering if anybody could help me rework this method to find the height of a binary search tree. So far, my code looks like this. However, the answer I'm getting is larger than the actual height by 1. But when I remove the +1 from my return statements, it's less than the actual height by 1. I'm still trying to wrap my head around recursion with these BST. Any help would be much appreciated.

<pre><code>public int findHeight(){
 if(this.isEmpty()){
 return 0;
 }
 else{
 TreeNode&lt;T&gt; node = root;
 return findHeight(node);
 }
}
private int findHeight(TreeNode&lt;T&gt; aNode){
 int heightLeft = 0;
 int heightRight = 0;
 if(aNode.left!=null)
 heightLeft = findHeight(aNode.left);
 if(aNode.right!=null)
 heightRight = findHeight(aNode.right);
 if(heightLeft &gt; heightRight){
 return heightLeft+1;
 }
 else{
 return heightRight+1;
 }
}
</code></pre>

Finding height in Binary Search Tree

数据结构

Swift

Java

我想知道是否有人可以帮我修改这个方法来找到二叉树的高度。到目前为止，我的代码如下所示。然而，我得到的答案是比实际高度大1。但是当我从我的return语句中删除+1时，它比实际高度小1。我仍然试图用这些BST来处理递归。任何帮助都将不胜感激。public int findHeight(){    if(this.isEm...

问在二叉搜索树中寻找高度
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在二叉搜索树中寻找高度EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在二叉搜索树中寻找高度
EN