📁 104. 二叉树的最大深度
深度就是树的高度，即只要左右子树其中有一个不为空，就继续往下递归，知道节点为空，向上返回。
int maxDepth(TreeNode* root) {
if(root == nullptr)
return 0;
return max(maxDepth(root->left) , maxDepth(root->right)) + 1;
}📁 94. 二叉树的中序遍历
中序遍历就是先访问左子树，再访问根节点，最后访问右子树。
class Solution {
public:
vector<int> ans;
vector<int> inorderTraversal(TreeNode* root) {
dfs(root);
return ans;
}
void dfs(TreeNode* root)
{
if(root == nullptr)
return ;
dfs(root->left);
ans.push_back(root->val);
dfs(root->right);
}
};📁 226. 翻转二叉树
对二叉树来一遍后序遍历，即先将左右子树翻转，保存反转后的左右子树的根节点，让root左右子树指针分别指向右子树，左子树。
TreeNode* invertTree(TreeNode* root) {
if(root == nullptr)
return root;
TreeNode* left = invertTree(root->left);
TreeNode* right = invertTree(root->right);
root->right = left;
root->left = right;
return root;
}📁 101. 对称二叉树
求对称二叉树，我们只需要判断左右子树是否满足满足下面这些性质：1. 左右子树根节点相同；2. 左子树的右子树 = 右子树的的左子树；3. 左子树的左子树 = 右子树的右子树。
bool isSymmetric(TreeNode* root) {
return isSameTree(root->left , root->right);
}
bool isSameTree(TreeNode* t1 , TreeNode* t2)
{
if(t1 == nullptr && t2 == nullptr)
return true;
if(t1 == nullptr || t2 == nullptr)
return false;
if(t1->val != t2->val)
return false;
return isSameTree(t1->left , t2->right) && isSameTree(t1->right , t2->left);
}📁 543. 二叉树的直径
以某个节点为根节点，统计做左子树的最长路径，在统计右子树的最长路径，左右子树最长路径相加就是该二叉树的直径。
递归函数向上返回该二叉树的最长路径。
int ans = 0;
int diameterOfBinaryTree(TreeNode* root) {
depth(root);
return ans;
}
int depth(TreeNode* root)
{
if(root == nullptr)
return 0;
int left = depth(root->left);
int right = depth(root->right);
ans = max(ans , left + right);
return max(left , right) + 1;
}📁 102. 二叉树的层序遍历
我们使用队列来完成二叉树的层序遍历，利用队列 [先入先出]的特性，将每一层的节点入队列，出队列按一层节点个数出队列。
如果出队列的每一个节点左右子树指针还有节点，在入队列，因为之前已经确定好了每一层节点个数，因此出队列时不回影响新入队列的节点。
vector<vector<int>> levelOrder(TreeNode* root) {
if(root == nullptr)
return vector<vector<int>>();
vector<vector<int>> ret;
queue<TreeNode*> q;
q.push(root);
while(!q.empty())
{
vector<int> tmp; //记录该层每一个节点的值
int sz = q.size(); //记录该层的节点个数
for(int i = 0 ; i < sz ; ++i)
{
TreeNode* node = q.front();q.pop();
tmp.push_back(node->val);
if(node->left)
q.push(node->left);
if(node->right)
q.push(node->right);
}
ret.push_back(tmp);
}
return ret;
}📁 108. 将有序数组转换为二叉搜索树
二叉搜索树的特征就是，左子树所有节点的值都小于根节点的值，右子树所有节点的值都大于根节点的值；对二叉搜索树进行前序遍历得到的结果是一个有序数组。
对于本题，我们就可以采用二分+前序递归的方法，将中间值mid作为根节点，比mid小的放在左子树，比mid大的放在右子树。
TreeNode* dfs(vector<int>& nums , int left , int right)
{
if(left > right)
return nullptr;
int mid = (left + right) >> 1;
TreeNode* node = new TreeNode(nums[mid]);
node->left = dfs(nums , left , mid - 1);
node->right = dfs(nums , mid + 1 , right);
return node;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
return dfs(nums , 0 , nums.size() - 1);
}📁 98. 验证二叉搜索树
二叉搜索树的特征就是，左子树所有节点的值都小于根节点的值，右子树所有节点的值都大于根节点的值；对二叉搜索树进行前序遍历得到的结果是一个有序数组。
根绝二叉树性质我们可以知道，对二叉树进行前序遍历时，root节点的值一定大于上一个已经被遍历的节点值（左子树中最右节点）prev。
递归函数返回值为是否为二叉搜索树，先遍历左子树是否二叉搜索树，在判断根节点值是否大于prev，然后在判断右子树是否是二叉搜索树。
特殊情况：初始化prev值为最小值；如果是空间点nullptr，返回值为true。
long prev = LONG_MIN;
bool dfs(TreeNode* root)
{
if(root == nullptr)
return true;
bool left = dfs(root->left);
if(!left)
return false;
if(root->val <= prev)
return false;
prev = root->val;
bool right = dfs(root->right);
return right;
}
bool isValidBST(TreeNode* root) {
return dfs(root);
}📁 230. 二叉搜索树中第 K 小的元素
从左往右递归，即前序遍历，依次--k，知道找到k为0的节点，这就是第k小的元素节点。
class Solution {
public:
int count = 1;
int ret = 0;
int kthSmallest(TreeNode* root, int k) {
count = k;
dfs(root);
return ret;
}
void dfs(TreeNode* root)
{
if(root == nullptr)
return ;
dfs(root->left);
count--;
if(count == 0)
{
ret = root->val;
return ;
}
dfs(root->right);
}
};📁 199. 二叉树的右视图
l利用BFS进行层序遍历，记录下来每一层的最后一个节点元素即可。
class Solution {
public:
vector<int> ret;
vector<int> rightSideView(TreeNode* root) {
if(root == nullptr)
return vector<int>();
queue<TreeNode*> q;
q.push(root);
while(!q.empty())
{
int sz = q.size();
for(int i = 0 ; i < sz; ++i)
{
TreeNode* node = q.front(); q.pop();
if(node->left)
q.push(node->left);
if(node->right)
q.push(node->right);
if(i == sz - 1)
ret.push_back(node->val);
}
}
return ret;
}
};📁 114. 二叉树展开为链表
判断左子树是否为空，如果为空，当前节点root不需要展开，已经展开为链表，处理当前节点的右子树。
如果不为空，需要找到左子树的最右节点作为右子树的根节点的前驱节点，当前节点root->left值为nullptr，右子树为左子树的根节点，处理完当前层后展开为链表，然后处理右子树。
class Solution {
public:
void flatten(TreeNode* root) {
TreeNode* cur = root;
while(cur)
{
if(cur->left)
{
TreeNode* left = cur->left;
TreeNode* prev = left;
while(prev->right)
prev = prev->right;
prev->right = cur->right;
cur->right = left;
cur->left = nullptr;
}
cur = cur->right;
}
}
};📁 105. 从前序与中序遍历序列构造二叉树
本题默认是所有值不重复
前序遍历的第一个节点一定是根节点，我们在中序遍历中查找根节点，即可找到左子树和右子树。
因此，递归遍历拿到prev中第一个节点一定是根节点，创建根节点，递归创建左子树根节点，在递归创建右子树根节点，直到数组中没有数据再能创建节点。
我们在中序遍历中找到根节点，就能知道左子树长度和右子树长度，我们采用空间换时间的方法，记录下来中序遍历中每个节点对应的下标。
class Solution {
public:
unordered_map<int,int> index;
TreeNode* myBuildTree(vector<int>& preorder, vector<int>& inorder , int prev_left , int prev_right,
int in_left , int in_rihgt)
{
if(prev_left > prev_right || in_left > in_rihgt)
return nullptr;
//记录前序遍历中root的下标 以及中序遍历中root的下标
int in_root = index[preorder[prev_left]];
//新建节点
TreeNode* root = new TreeNode(preorder[prev_left]);
//记录左子树的个数
int sz = in_root - in_left;
root->left = myBuildTree(preorder , inorder , prev_left + 1 , prev_left + sz,
in_left , in_root - 1);
root->right = myBuildTree(preorder , inorder , prev_left + 1 + sz , prev_right,
in_root + 1 , in_rihgt);
return root;
}
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
int sz = preorder.size();
for(int i = 0 ; i < sz ; ++i)
index[inorder[i]] = i;
return myBuildTree(preorder , inorder , 0 , sz - 1 , 0 , sz - 1);
}
};📁 437. 路径总和 III
我们采用前缀和的方法，从根节点开始，不断地往某一分支+root->val值为cur，如果满足公式：targetNum + ? = cur，如果 ？ 存在，就表明上述公式成立，targetNum一定存在，ans += 齐前缀和为 ？的个数。
步骤：判断从当前节点往上是否满足公式，如果满足，ans += 前缀和为 ？的个数；在判断左右子树，即ans += 左右子树中满足公式的前缀和的个数。
class Solution {
public:
unordered_map<long long , long long> hash;
int pathSum(TreeNode* root, int targetSum) {
hash[0] = 1;
return dfs(root , 0 , targetSum);
}
int dfs(TreeNode* root , long long cur ,long long targetSum)
{
if(root == nullptr)
return 0;
int ans = 0;
cur += root->val;
if(hash.find(cur - targetSum) != hash.end())
ans += hash[cur - targetSum];
hash[cur]++;
ans += dfs(root->left , cur , targetSum);
ans += dfs(root->right , cur , targetSum);
hash[cur]--;
return ans;
}
};📁 236. 二叉树的最近公共祖先
分为以下三种情况，递归查找p节点和q节点，如果找到向上返回，如果没有返回nullptr，分别查找左右子树。
1. 如果左右子树递归结果为空，说明没有找到p，q节点，返回nullptr。
2. 如果左子树为空，说明p和q节点在右子树中，p或q节点为另一个节点的最近公共祖先。
3. 右子树为空，同理可得。
4. 如果左右子树都不为空，说明此时，root为p和q的最近公共祖先。
class Solution {
public:
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root == nullptr || root == p || root == q)
return root;
TreeNode* left = lowestCommonAncestor(root->left , p , q);
TreeNode* right = lowestCommonAncestor(root->right , p , q);
if(!left)
return right;
if(!right)
return left;
return root;
}
};📁 124. 二叉树中的最大路径和
本题，我们采用后序遍历的思路，先查找左子树中最大值的路径，最查找右子树中最大值的路径，然后+上根节点的值，记录下来最大值即可。
返回值为，从根节点开始，到左右子树中找到一条值最大的路径，向上返回该路径的值+根节点的值。
递归结束条件就是找到叶子节点，向上返回。
class Solution {
public:
int ret = INT_MIN;
int maxPathSum(TreeNode* root) {
dfs(root);
return ret;
}
int dfs(TreeNode* root)
{
if(root == nullptr)
return 0;
int left = max(0 , dfs(root->left));
int right = max(0 , dfs(root->right));
ret = max(ret , root->val + left + right);
return root->val + max(left , right);
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
