513.找树左下角的值
迭代法
使用层次遍历,并记录每一层的第一个元素,返回最后一层第一个元素即是答案。
递归法
- 参数与返回值:
void traverse(TreeNode* node, int depth)
- 终止条件:如果depth大于maxDepth,更新maxDepth和result
- 单层逻辑:遍历左子树,遍历右子树,返回。
class Solution {
public:
int result;
int maxDepth = 0;
void traverse(TreeNode* node, int depth) {
if (depth > maxDepth) {
maxDepth = depth;
result = node->val;
}
if (node->left) {
depth++;
traverse(node->left, depth);
depth--;
}
if (node->right) {
depth++;
traverse(node->right, depth);
depth--;
}
return;
}
int findBottomLeftValue(TreeNode* root) {
traverse(root, 1);
return result;
}
};
112. 路径总和
- 确定参数和返回值:
bool hasPathSum(TreeNode* root, int targetSum)
- 终止条件:如果root为叶子节点且targetSum为0,返回true,如果root为叶子节点且targetSum不为0,返回false
- 单层逻辑:如果左子树或右子树hasPathSum返回true,则返回true,否则返回false。
class Solution {
public:
bool hasPathSum(TreeNode* root, int targetSum) {
if (root == nullptr) return false;
if (root->left == nullptr && root->right == nullptr) {
if (targetSum == root->val) return true;
else return false;
}
if (root->left) {
targetSum -= root->val;
if (hasPathSum(root->left, targetSum)) return true;
targetSum += root->val;
}
if (root->right) {
targetSum -= root->val;
if (hasPathSum(root->right, targetSum)) return true;
targetSum += root->val;
}
return false;
}
};
113. 路径总和ii
总体思路上题一致。
class Solution {
public:
vector<int> path;
vector<vector<int>> result;
void traverse(TreeNode* node, int count) {
if (node->left == nullptr && node->right == nullptr) {
if (count == 0)
result.push_back(path);
return;
}
if (node->left) {
count -= node->left->val;
path.push_back(node->left->val);
traverse(node->left, count);
count += node->left->val;
path.pop_back();
}
if (node->right) {
count -= node->right->val;
path.push_back(node->right->val);
traverse(node->right, count);
count += node->right->val;
path.pop_back();
}
return;
}
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
if (root == nullptr)
return result;
targetSum -= root->val;
path.push_back(root->val);
traverse(root, targetSum);
return result;
}
};
106.从中序与后序遍历序列构造二叉树
- 判断后序数组是否为空,为空则返回null
- 根据后序数组最后一个元素找到根节点的值
- 如果后序数组只有一个元素,则返回该根节点
- 根据根节点划分中序数组
- 根据中序数组左子树个数点划分后序数组
- 递归处理左子树和右子树
class Solution {
public:
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if (postorder.size() == 0)
return nullptr;
int rootVal = postorder[postorder.size() - 1];
TreeNode* root = new TreeNode(rootVal);
if (postorder.size() == 1)
return root;
int index = 0;
for (;index < inorder.size(); index++) {
if (inorder[index] == rootVal)
break;
}
vector<int> leftInorder(inorder.begin(), inorder.begin() + index);
vector<int> rightInorder(inorder.begin() + index + 1, inorder.end());
vector<int> leftPostorder(postorder.begin(), postorder.begin() + index);
vector<int> rightPostorder(postorder.begin() + index, postorder.end() - 1);
root->left = buildTree(leftInorder, leftPostorder);
root->right = buildTree(rightInorder, rightPostorder);
return root;
}
};
105. 从前序与中序遍历序列构造二叉树
class Solution {
public:
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
if (preorder.size() == 0)
return nullptr;
int rootVal = preorder[0];
TreeNode* root = new TreeNode(rootVal);
if (preorder.size() == 1)
return root;
int index = 0;
for (;index < inorder.size(); index++) {
if (inorder[index] == rootVal)
break;
}
vector<int> leftInorder(inorder.begin(), inorder.begin() + index);
vector<int> rightInorder(inorder.begin() + index + 1, inorder.end());
vector<int> leftPreorder(preorder.begin() + 1, preorder.begin() + index + 1);
vector<int> rightPreorder(preorder.begin() + index + 1, preorder.end());
root->left = buildTree(leftPreorder, leftInorder);
root->right = buildTree(rightPreorder, rightInorder);
return root;
}
};