递归法:
class Solution {
public:
int getHeight(TreeNode* root) {
if(root == NULL) {
return 0;
}
int left = getHeight(root->left);
int right = getHeight(root->right);
if(left == -1 || right == -1 || abs(left - right) > 1) return -1;
return left > right ? left + 1: right + 1;
}
bool isBalanced(TreeNode* root) {
if(root == NULL) return true;
if(getHeight(root) == -1) return false;
return true;
}
};
class Solution {
public:
void traversal(TreeNode* root, vector<int>& path, vector<string>& result) {
path.push_back(root->val);
if(root->left == NULL && root->right == NULL) {
string sPath;
for(int i = 0; i < path.size()-1; i++) {
sPath += to_string(path[i]);
sPath += "->";
}
sPath += to_string(path[path.size()-1]);
result.push_back(sPath);
return;
}
if(root->left != NULL) {
traversal(root->left, path, result);
path.pop_back();
}
if(root->right != NULL) {
traversal(root->right, path, result);
path.pop_back();
}
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<int> path;
vector<string> result;
traversal(root, path, result);
return result;
}
};
递归法:
class Solution {
public:
int sum(TreeNode* root) {
if(root == NULL) return 0;
if(root->left == NULL && root->right == NULL) return 0;
if(root->left != NULL && root->left->left == NULL && root->left->right == NULL) {
return root->left->val + sum(root->right);
}
return sum(root->left) + sum(root->right);
}
int sumOfLeftLeaves(TreeNode* root) {
if(root == NULL) return 0;
return sum(root);
}
};
迭代法:
class Solution {
public:
int sumOfLeftLeaves(TreeNode* root) {
if(root == NULL) return 0;
stack<TreeNode*> sta;
sta.push(root);
int res = 0;
while(!sta.empty()) {
TreeNode* tem = sta.top();
sta.pop();
if(tem->left != NULL && tem->left->left == NULL && tem->left->right == NULL) {
res += tem->left->val;
}
if(tem->right) sta.push(tem->right);
if(tem->left) sta.push(tem->left);
}
return res;
}
};
递归法:
class Solution {
public:
int countNodes(TreeNode* root) {
if(root == NULL) return 0;
int left = countNodes(root->left);
int right = countNodes(root->right);
return left + right + 1;
}
};