/** * 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; } }