/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
int maxDepth(struct TreeNode* root) {
if(root == NULL)
return 0;
int l = maxDepth(root->left);
int r = maxDepth(root->right);
return l>r?l+1:r+1;
}
int maxDepth(Node* root)
{
if (root == NULL)
return 0;
return std::max(maxDepth(root->left), maxDepth(root->right)) + 1;
}
int maxDepth(TreeNode* root) {
if (!root) return 0;
int leftHeight = maxDepth(root->left);
int rightHeight = maxDepth(root->right);
return (leftHeight > rightHeight) ? leftHeight+1: rightHeight+1;
}
int maxDepth(TreeNode *root) {
if (root == NULL) {
return 0;
}
int depth = 1;
depth += max(maxDepth(root->left), maxDepth(root->right));
return depth;
}
int maxDepth(TreeNode *root) {
// Note: The Solution object is instantiated only once and is reused by each test case.
if (!root) {
return 0;
}
return max(maxDepth(root->left), maxDepth(root->right)) + 1;
}
int maxDepth(TreeNode* root){
if (!root) return 0;
return(1+max(maxDepth(root->right),maxDepth(root->left)));
}
int maxDepth(TreeNode *root) {
if(root==NULL)
return 0;
return max(maxDepth(root->left),maxDepth(root->right))+1;
}
int maxDepth(TreeNode *root) {
if(root == NULL)
return 0;
int left = maxDepth(root->left),
right = maxDepth(root->right);
return left > right? (left + 1): (right + 1);
}
int maxDepth(TreeNode *root) {
int depth;
if (!root)
depth = 0;
else
depth = max(maxDepth(root->left), maxDepth(root->right)) + 1;
return depth;
}
int maxDepth(pnode root) {
if (!root) return 0;
else {
int ldepth = maxDepth(root->left);
int rdepth = maxDepth(root->right);
return ((ldepth > rdepth) ? ldepth + 1 : rdepth + 1);
}
}
int maxDepth(TreeNode* root) {
if(root == NULL){
return 0;
}
int maxLeftDepth = maxDepth(root->left);
int maxRightDepth = maxDepth(root->right);
return maxLeftDepth > maxRightDepth ? maxLeftDepth + 1 : maxRightDepth + 1;
}
int maxDepth(TreeNode* root) {
if(root == NULL) {
return 0;
}
int le = maxDepth(root->left);
int ri = maxDepth(root->right);
return std::max(le, ri) + 1;
}
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
int maxDepth(struct TreeNode* root)
{
if (root == NULL)
return 0;
int left = maxDepth(root->left);
int right = maxDepth(root->right);
return left > right ? left + 1 : right + 1;
}
int maxDepth(TreeNode *root) {
if (root == nullptr)
return 0;
if (root->left == nullptr && root->right == nullptr)
return 1;
int l = maxDepth(root->left), r = maxDepth(root->right);
return (l < r ? r : l) + 1;
}
/**
* Problem: Given a binary tree, find its maximum depth. The maximum depth is the number of
* nodes along the longest path from the root node down to the farthest leaf node.
* Solve: recusive
* Tips: add 1
*/
int maxDepth(TreeNode* root) {
if (!root) return 0;
int leftHeight = 1 + maxDepth(root->left);
int rightHeight = 1 + maxDepth(root->right);
return leftHeight > rightHeight ? leftHeight : rightHeight;
}
void maxDepth(TreeNode *root, int current, int &max_depth) {
if (NULL == root) {
return;
}
max_depth = max(max_depth, current);
maxDepth(root->left, current + 1, max_depth);
maxDepth(root->right, current + 1, max_depth);
}
void maxDepth(TreeNode *root, int depth, int *res) {
if (root->left == NULL && root->right == NULL) {
*res = max(*res, depth);
return;
}
if (root->left) maxDepth(root->left, depth + 1, res);
if (root->right) maxDepth(root->right, depth + 1, res);
}
int maxDepth(TreeNode *root) {
if (root == nullptr) return 0;
int lh = maxDepth(root->left);
int rh = maxDepth(root->right);
return std::max(lh, rh) + 1;
}
int maxDepth(TreeNode *root)
{
if(NULL==root)
return 0;
int ldepth=maxDepth(root->left);
int rdepth=maxDepth(root->right);
return 1+(ldepth>rdepth?ldepth:rdepth);
}
private int maxDepth(TreeNode root) {
if (root == null) return 0;
int L = maxDepth(root.left);
if (L == -1) return -1;
int R = maxDepth(root.right);
if (R == -1) return -1;
return (Math.abs(L - R) <= 1) ? (Math.max(L, R) + 1) : -1;
}
int maxDepth(TreeNode* root) {
if (root == nullptr) {
return 0;
}
return 1 + max(maxDepth(root->left),
maxDepth(root->right));
}
int maxDepth(TreeNode* root) {
if(root==NULL) return 0;
int left=maxDepth(root->left);
int right=maxDepth(root->right);
return max(left,right)+1;
}
int maxDepth(struct TreeNode *root) {
if(root == NULL) {
return 0;
}
int leftDepth = 1, rightDepth = 1;
leftDepth = maxDepth(root->left)+1;
rightDepth = maxDepth(root->right)+1;
return leftDepth>rightDepth?leftDepth:rightDepth;
}
int minDepth(tree*root)
{
if(!node) return 0;
int leftdepth=maxDepth(root->left)+1;
int rightdepth=maxDepth(root->right)+1;
if(leftdept==1&&rightdepth!=1) return rightdepth;
if(leftdept!=1&&rightdepth==1) return leftdepth;
return leftdept>rightdepth?leftdept:rightdept;
}
int maxDepth(TreeNode *root) {
if (root == NULL) return 0;
int l = maxDepth(root->left);
int r = maxDepth(root->right);
if (l == -1 || r == -1 || abs(l - r) > 1)
return -1;
return max(l, r) + 1;
}
bool isBalanced(TreeNode *root) {
if (!root) //Note: an empty tree is a blanced tree
return true;
int left = maxDepth(root->left),
right = maxDepth(root->right);
return abs(left - right) <= 1 && isBalanced(root->left) && isBalanced(root->right);
}
/**
* Definition for binary tree
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
int maxDepth(struct TreeNode *root) {
int lDepth, rDepth;
if(root == NULL){
return 0;
}
lDepth = maxDepth(root->left);
rDepth = maxDepth(root->right);
return (lDepth > rDepth ? lDepth:rDepth) + 1;
}
int maxDepth(TreeNode* root) {
if (!root) return 0;
int leftDepth = maxDepth(root->left);
int rightDepth = maxDepth(root->right);
return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
}
bool isBalanced(TreeNode *root) {
if(root==NULL)
return true;
int leftHeight = maxDepth(root->left);
int rightHeight = maxDepth(root->right);
return abs(leftHeight-rightHeight)<=1 && isBalanced(root->left) && isBalanced(root->right);
}
int maxDepth(struct node* node) {
if (!node) return 0;
else {
if (maxDepth(node->left) > maxDepth(node->right))
return maxDepth(node->left) + 1;
else
return maxDepth(node->right) + 1;
}
}
