110.平衡二叉树
https://leetcode.cn/problems/balanced-binary-tree/description/
给定一个二叉树,判断它是否是 平衡二叉树(该树所有节点的左右子树的深度相差不超过 1 )
class Solution {
public:
// 返回以该节点为根节点的二叉树的高度,如果不是平衡二叉树了则返回-1
int getHeight(TreeNode* node) {
if (node == NULL) {
return 0;
}
int leftHeight = getHeight(node->left); // 计算左子树的最大高度
if (leftHeight == -1) return -1;
int rightHeight = getHeight(node->right); // 计算右子树的最大高度
if (rightHeight == -1) return -1;
return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
}
bool isBalanced(TreeNode* root) {
return getHeight(root) == -1 ? false : true;
}
};
257. 二叉树的所有路径
class Solution {
public:
void traversal(TreeNode* node, vector<int>& path, vector<string>& res) {
//由于递归的终止条件是遍历到叶子节点结束,我们应该向存储节点值,保证叶子节点可以被加到path中
path.push_back(node->val); //中
//递归中止条件的判断
if (node->left == nullptr && node->right == nullptr) {
//遍历到叶子节点
string s;
for (int i = 0; i < path.size() - 1; ++i) {
s += to_string(path[i]);
s += "->";
}
s += to_string(path[path.size() - 1]);
res.push_back(s);
}
if (node->left) { //遍历左子树
traversal(node->left, path, res);
path.pop_back(); //回退到node的阶段 回溯
}
if (node->right) { //遍历右子树
traversal(node->right, path, res);
path.pop_back(); //回退到node的阶段 回溯
}
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<int> path;
vector<string> res;
traversal(root, path, res);
return res;
}
};
404.左叶子之和
class Solution {
public:
int sumOfLeftLeaves(TreeNode* root) {
if (root == nullptr) {
return 0;
}
// 通过节点的父节点来判断其左孩子是不是左叶子
if (root->left == nullptr && root->right== nullptr) {
return 0;
}
int leftValue = sumOfLeftLeaves(root->left); // 左
if (root->left && !root->left->left && !root->left->right) { // 左子树就是一个左叶子的情况
leftValue = root->left->val;
}
int rightValue = sumOfLeftLeaves(root->right); // 右
int sum = leftValue + rightValue; // 中
return sum;
}
};
222.完全二叉树的节点个数
222.完全二叉树的节点个数
对于普通二叉树:遍历二叉树来计算节点个数;代码同二叉树的前序/中序/后序/层序遍历
前序遍历
class Solution {
public:
//前序遍历
void traversal(TreeNode* root, int& cnt) {
if (root == nullptr) {
return;
}
++cnt; // 中
traversal(root->left, cnt); // 左
traversal(root->right, cnt); // 右
}
int countNodes(TreeNode* root) {
int cnt = 0;
traversal(root, cnt);
return cnt;
}
};
后序遍历
class Solution {
public:
int countNodes(TreeNode* root) {
if (root == nullptr) {
return 0;
}
int leftCnt = countNodes(root->left);
int rightCnt = countNodes(root->right);
return leftCnt + rightCnt + 1;
}
};
利用完全二叉树的特性
除了最底层节点没填满外,其余每层节点数都达到最大值,并且最后一层的节点都集中在该层最左边的若干位置;
完全二叉树中的节点的左右子树,要么都是满二叉树,要么一颗是满二叉树,一颗是完全二叉树;
class Solution {
public:
int countNodes(TreeNode* root) {
if (root == nullptr) {
return 0;
}
TreeNode* left = root->left;
TreeNode* right = root->right;
int leftDepth = 0, rightDepth = 0;
while (left) { // 求左子树深度
left = left->left;
leftDepth++;
}
while (right) { //求右子树深度
right = right->right;
rightDepth++;
}
if (leftDepth == rightDepth) {
// 是一颗满二叉树
return (2 << leftDepth) - 1;
// 这里的深度我们计算的子树的深度,那么整棵树的深度为 leftDepth + 1
// 满二叉树节点个数公式为 2 ^ (leftDepth + 1) -1
// 位运算 2 << leftDepth,相当于 2 ^ (leftDepth + 1)
}
int leftCnt = countNodes(root->left);
int rightCnt = countNodes(root->right);
return leftCnt + rightCnt + 1;
}
};