513.找树左下角的值
给你一个二叉树的根节点 root,请找出该二叉树的 最底层 最左边 节点的值。题目要求找的是二叉树最底层、最左边的叶子节点的值,首先是最底层,其次是最左边。符合要求的节点也可能是在根节点的右子树,所以一直遍历左子树可能得不到正确答案。这里我们使用两种方法:一种是,利用前序(中序、后续都可,只要是左边优先)遍历,保持左边优先;一种是,层序遍历。
class Solution {
public:
int maxDepth = INT_MIN;
int result;
void traversal(TreeNode* node, int depth) {
if (node->left == nullptr && node->right == nullptr) {
if (depth > maxDepth) {
maxDepth = depth;
result = node->val;
}
return ;
}
if (node->left != nullptr) traversal(node->left, depth + 1);
if (node->right != nullptr) traversal(node->right, depth + 1);
return ;
}
int findBottomLeftValue(TreeNode* root) {
traversal(root, 1);
return result;
}
};
递归的三个步骤:1.确定形参列表,二叉树的根节点和用于跟踪递归层数的深度;2.确定终止条件,如果当前节点为叶子节点,且 depth 大于 maxDepth,则记录当前节点的内容,结束当前递归;3.确定基本递归逻辑,确保左边优先,所以先左再右。代码中为前序遍历,保证在每一层中,第一个遍历该层最左边的节点,如果该节点满足条件,修改 maxDepth 为 depth,同时 result 记录该节点的值,即使同一层存在其他节点,因为 depth 不大于 maxDepth,也不会修改 result 中的内容。
class Solution {
public:
int findBottomLeftValue(TreeNode* root) {
queue<TreeNode*> que;
if (root != nullptr) que.push(root);
int value = root->val;
while (!que.empty()) {
int size = que.size();
while (size--) {
TreeNode* node = que.front();
que.pop();
value = node->val;
if (node->right != nullptr) que.push(node->right);
if (node->left != nullptr) que.push(node->left);
}
}
return value;
}
};
上述代码为层序遍历实现求最左下角值,层序遍历很好理解,遍历至最底层,记录该层第一个遇到的节点,即为最底层、最左节点,只要确保左边优先即可,这是代码随想录里的思路。我在使用层序遍历时,略有不同。如代码所示,如果我们从右边开始遍历每一层,并逐层逐个记录元素的内容,最后记录的元素一定是最底层、最左的节点。因为遍历顺序是自右向左、自上向下,最后一个元素必定满足 最底层 最左边。
112.路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum。判断该树中是否存在根节点到叶子节点的路径,这条路径上所有节点值相加等于目标和 targetSum。如果存在,返回 true;否则,返回 false。根据题意,必须是从根节点出发到叶子节点,这条路径上的值和等于目标和。如果存在一条满足题意的路径,返回真,反之假。我们先使用前序遍历(中序和后序也可,只需要遍历节点即可,不需要处理节点)的递归法解决问题。
递归法三步骤,1.确定参数列表,二叉树的根节点,目标和;2.确定终止条件,如果当前节点为叶子节点,且路径上的节点和等于目标和,结束递归;3.确定递归基本逻辑,前序,根左右,一直向下即可。
class Solution {
public:
bool traversal(TreeNode* node, int sum) {
sum -= node->val;
if (!node->left && !node->right && sum == 0) return true;
if (node->left) {
if (traversal(node->left, sum)) return true;
}
if (node->right) {
if (traversal(node->right, sum)) return true;
}
return false;
}
bool hasPathSum(TreeNode* root, int targetSum) {
if (root == nullptr) return false;
return traversal(root, targetSum);
}
};
class Solution {
public:
bool hasPathSum(TreeNode* root, int targetSum) {
if (root == nullptr) return false;
if (!root->left && !root->right && targetSum == root->val) return true;
return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);
}
};
上述代码,定义了一个 bool 类型的递归函数 traversal,接受二叉树节点指针和一个整数作为变量,当 node 为叶子节点且路径和等于目标和时,结束递归,返回真。在向下递归的时候,如果找到一条符合要求的路径,直接结束递归函数,返回真。
class Solution {
public:
bool hasPathSum(TreeNode* root, int targetSum) {
stack<pair<TreeNode*, int>> st;
if (root != nullptr) st.push(pair<TreeNode*, int>(root, root->val));
while (!st.empty()) {
pair<TreeNode*, int> node = st.top();
st.pop();
if (!node.first->left && !node.first->right && node.second == targetSum) return true;
if (node.first->right) st.push(pair<TreeNode*, int>(node.first->right, node.second + node.first->right->val));
if (node.first->left) st.push(pair<TreeNode*, int>(node.first->left, node.second + node.first->left->val));
}
return false;
}
};
第二种方法,迭代法,注意,和之前定义栈的类型不同,这里定义pair<TreeNode*,int>类型的栈,在 pair 中,第二个位置存放从根节点到当前节点的路径和,以 pair 中第二个元素和目标和是否相同作为判定依据。
113.路径总和Ⅱ
在112.路径总和的基础上,返回所有满足条件的路径。
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void traversal(TreeNode* node, int count) {
count -= node->val;
if (!node->left && !node->right && count == 0) {
result.push_back(path);
return ;
}
if (node->left) {
path.push_back(node->left->val);
traversal(node->left, count);
path.pop_back();
}
if (node->right) {
path.push_back(node->right->val);
traversal(node->right, count);
path.pop_back();
}
return ;
}
public:
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
if (root == nullptr) return result;
path.push_back(root->val);
traversal(root, targetSum);
return result;
}
};
使用 path 记录走过的路径,result 为结果集。递归的终止条件与112.路径总和相同,当满足条件时,将 path 加入结果集 result。依旧是前序遍历,本题必须是前序遍历,因为需要在path中记录根节点的信息。注意在深入下一层时,向 path 中添加该节点元素,当返回上一层时,需要从path 中删除该节点元素,递归 + 回溯。
106.从中序与后序遍历构造二叉树
class Solution {
private:
TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
if (postorder.size() == 0) return nullptr;
int rootValue = postorder[postorder.size() - 1];
TreeNode* root = new TreeNode(rootValue);
if (postorder.size() == 1) return root;
int delimiterIndex;
for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
if (inorder[delimiterIndex] == rootValue) break;
}
vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());
postorder.resize(postorder.size() - 1);
vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());
root->left = traversal(leftInorder, leftPostorder);
root->right = traversal(rightInorder,rightPostorder);
return root;
}
public:
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if (inorder.size() == 0 || postorder.size() == 0) return nullptr;
return traversal(inorder, postorder);
}
};
掌握的还不是很好,下次再聊。