110.平衡二叉树
文章讲解:https://programmercarl.com/0110.%E5%B9%B3%E8%A1%A1%E4%BA%8C%E5%8F%89%E6%A0%91.html
视频讲解:https://www.bilibili.com/video/BV1Ug411S7my/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375
题目链接:https://leetcode.cn/problems/balanced-binary-tree/description/
实现情况：
平衡二叉树（Balanced Binary Tree）是一种特殊的二叉搜索树（Binary Search Tree, BST），它要求树中任何节点的两个子树的高度最大差别为1
求高度使用后序遍历
求深度使用前序遍历
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
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;
int result;
if (abs(leftHeight - rightHeight) > 1) { // 中
result = -1;//有一边出现大于1的情况，就不是平衡二叉树了
} else {
result = 1 + max(leftHeight,
rightHeight); // 记录当前根节点的高度
}
}
bool isBalanced(TreeNode* root) {
return getHeight(root) == -1 ? false : true;
}
};
257. 二叉树的所有路径
文章讲解:https://programmercarl.com/0257.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%89%80%E6%9C%89%E8%B7%AF%E5%BE%84.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解:https://www.bilibili.com/video/BV1ZG411G7Dh/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375
题目链接:https://leetcode.cn/problems/binary-tree-paths/description/
实现情况：
得到从根节点到所有叶子节点的路径
这里使用递归的前序遍历
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
// path单条路径
// result 最后的结果
void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {
path.push_back(cur->val); // 中 进来就先记录一下
if (cur->left == NULL && cur->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 (cur->left) { // 左 存在左孩子 就去出来 因为是临时加的
// 使用要pop出来，单层递归逻辑
traversal(cur->left, path, result);
path.pop_back(); // 回溯
}
if (cur->right) { // 右 存在右孩子
traversal(cur->right, path, result);
path.pop_back(); //
}
}
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> result;
vector<int> path;
if (root == NULL)
return result;
traversal(root, path, result);
return result;
}
};
404.左叶子之和
文章讲解:https://programmercarl.com/0404.%E5%B7%A6%E5%8F%B6%E5%AD%90%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解:https://www.bilibili.com/video/BV1GY4y1K7z8/?spm_id_from=333.788&vd_source=e70917aa6392827d1ccc8d85e19e8375
题目链接:https://leetcode.cn/problems/sum-of-left-leaves/
实现情况：
1、左叶子是叶子节点
2、父节点的左孩子
使用递归的后序遍历代码比较简洁
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
int sumOfLeftLeaves(TreeNode* root) {
if (root == NULL)
return 0;
if (root->left == NULL && root->right == NULL) // 叶子节点
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.完全二叉树的节点个数
文章讲解:https://programmercarl.com/0222.%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%8A%82%E7%82%B9%E4%B8%AA%E6%95%B0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解:
题目链接:https://leetcode.cn/problems/count-complete-tree-nodes/description/
实现情况：
完全二叉树的定义：若设二叉树的深度为h，除第h层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层所有的结点都连续集中在最左边，这就是完全二叉树
当在普通二叉树定义
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
int getNodesNum(TreeNode* cur) {
if (cur == NULL)
return 0;
int leftNum = getNodesNum(cur->left); // 左
int rightNum = getNodesNum(cur->right); // 右
int treeNum = leftNum + rightNum + 1; // 中
return treeNum;
}
public:
int countNodes(TreeNode* root) { return getNodesNum(root); }
};
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
public:
int countNodes(TreeNode* root) {
if (root == nullptr)
return 0;
// 开始根据左深度和右深度是否相同来判断该子树是不是满二叉树
TreeNode* left = root->left;
TreeNode* right = root->right;
int leftDepth = 0,
rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
while (left) { // 求左子树深度
left = left->left;
leftDepth++;
}
while (right) { // 求右子树深度
right = right->right;
rightDepth++;
}
if (leftDepth == rightDepth) {
// return (2 << leftDepth) - 1; //
int result1 = 1;
for (int i = 0; i < leftDepth; ++i) {
result1 *= 2;
}
result1 -= 1;
return result1;
}
int leftTreeNum = countNodes(root->left); // 左
int rightTreeNum = countNodes(root->right); // 右
int result = leftTreeNum + rightTreeNum + 1; // 中
return result;
}
};
对于计算2的n次方-1的整数结果，(2 << leftDepth) - 1 是最直接、最高效且最启发式的写法。
pow 函数是设计为处理浮点数的
