CareerCup

public class Node {
    public Node left = null;
    public Node right = null;

    public Node(Node left, Node right) {
        this.left = left;
        this.right = right;
    }
}

public int maxHeight(Node x) {
    if (x == null) {
        return 0;
    }
    return Math.max(maxHeight(x.left), maxHeight(x.right)) + 1;
}

def max_height root
	if !root
		return 0
	end


	right = heigth root.right
	left = heigth(root.left)
	
	return 1 + [right,left].max

end

puts heigth n1

post order traversal.
depth(tree) = 1 + max(depth (left-subtree), depth(right-subtree))
depth of leaf node is zero.

int d(Node node) {

if (node == null) {
    return 0;
}

return 1 + Math.max(d(node.left), d(node.right));
}

straightforward O(n) solution:
do InOrder Traversal, and maintain two variables (a max and a counter) as follows: while traversing in depth increment counter (and while walking up decrement it), when you hit a leaf node do a check to see if a counter value is greater than the max value. If so - update max variable, then continue traversing.

template <class T>
int CBst<T>::GetHeightOfTree(BstNode<T>* pRootNode)
{	
	if(NULL == pRootNode )
		return -1;
	return max((GetHeightOfTree(pRootNode->GetLeftChild())+1),(GetHeightOfTree(pRootNode->GetRightChild())+1));
}

#include <iostream>
using namespace std;

class tree {
public:
	tree *left;
	tree *right;
	int data;
	tree(tree *l,tree *r, int d) : left(l), right(r), data(d) { }
};

int findMaxDepth(tree *node)
{
	if (node == 0) {
		return 0;
	}
	return (max(findMaxDepth(node->left), findMaxDepth(node->right))) + 1;
}

int main() {
	// your code goes here
	tree *root, *buffy, *dummy;
	root = buffy = new tree(0,0,1);
	for (int i = 2; i < 100; i++) {
		dummy = new tree(0,0,i);
		if (rand() % 2) { 
			buffy->left = dummy;
			buffy = buffy->left;
		} else {
			buffy->right = dummy;
			buffy = buffy->right;
		}
	}
	cout << "depth " << findMaxDepth(root);
	return 0;

}

Level order traversal should be used for it

int depth_tree2(struct btree **b) {
if((*b)->left == NULL && (*b)->right == NULL )
return 0;

int l=0, r=0;

if((*b)->left != NULL)
l = depth_tree2( &((*b)->left)) + 1;
if((*b)->right != NULL)
r = depth_tree2( &((*b)->right)) + 1;

if(l>r)
return l;
else
return r;
}

Your can use logic for printing of nodes level wise is this question.