一、513.找树左下角的值
代码如下:
class Solution {
public:
int maxDepth = INT_MIN;
int result;
void traversal(TreeNode* root, int depth) {
if (root->left == NULL &&root->right == NULL) { //终止条件:遇到叶子节点
if (depth > maxDepth) { // 如果叶子节点深度大于maxDepth
maxDepth = depth; // 更新最大深度
result = root->val; // 最大深度最左边的数值,【为什么?】
}
return;
}
if (root->left) { // 左
depth++; // 向下遍历了,深度加1
traversal(root->left, depth);
depth--; // 回溯,深度减一
}
if (root->right) {
depth++;
traversal(root->right, depth);
depth--;
}
}
int findBottomLeftValue(TreeNode* root) {
traversal(root, 0);
return result;
}
};
二、112.路径总和、113.路径总和II
112.路径总和
代码如下:
class Solution {
public:
bool traversal(TreeNode* cur,int count) {
//终止条件:如果遇到叶子节点且计数为0,说明找到合法的路径;如果遇到叶子节点但计数不为0,返回false
if (cur->left == NULL && cur->right == NULL && count == 0) return true;
if (cur->left == NULL && cur->right == NULL && count != 0) return false;
if (cur->left) { //向左孩子遍历的逻辑,先判断是否为空
count -= cur->left->val; //递归,处理节点
if (traversal(cur->left, count)) return true;
count += cur->left->val; //回溯,撤销处理结果 (用自己的话来说:保留向右边遍历的可能)
}
if (cur->right) {
count -= cur->right->val;
if (traversal(cur->right, count)) return true;
count += cur->right->val;
}
return false;
}
bool hasPathSum(TreeNode* root, int targetSum) {
if (root == NULL) return false;
return traversal(root, targetSum - root->val); //主函数中就传入targetSum减去root->val
}
};
113.路径总和II
代码如下:
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
void traversal (TreeNode* cur, int count) { // 因为要遍历整个数,递归函数不需要返回值,最后结果收集在result中
// 终止条件:遍历到叶子节点且count为0,将遍历所经过的路径放入result中;若遍历到叶子节点count不为0,则直接return
if (cur->left == NULL && cur->right == NULL && count == 0) {
result.push_back(path);
return ;
}
if (cur->left == NULL && cur->right == NULL && count != 0) return ;
// 单层递归逻辑:若左孩子不为空,将左孩子的值放入path中,count减去该值,对左孩子的左孩子进行遍历,回溯,count恢复,path恢复
if (cur->left) {
path.push_back(cur->left->val);
count -= cur->left->val;
traversal(cur->left, count);
count += cur->left->val;
path.pop_back();
}
if (cur->right) {
path.push_back(cur->right->val);
count -= cur->right->val;
traversal(cur->right, count);
count += cur->right->val;
path.pop_back();
}
return ;
}
vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
result.clear(); // 将result的size(当前储存元素的数量)置为0(但不会改变result的容量,不会释放程序分配的动态内存,真正释放内存的是析构函数)
path.clear();
if (root == NULL) return result;
path.push_back(root->val);
traversal(root, targetSum - root->val);
return result;
}
};
三、106.从中序与后序遍历序列构造二叉树
代码如下:
class Solution {
public:
TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
// 第一步:如果数组大小为0,说明为空节点
if (postorder.size() == 0) return NULL;
// 第二步:取后序最后一个元素为节点元素
int rootValue = postorder[postorder.size() - 1];
TreeNode* root = new TreeNode(rootValue);
// 后序的数组大小为1,即为叶子节点
if (postorder.size() == 1) return root;
// 第三步:找到节点元素的值在中序数组中的位置,作为切割点
int delimiterIndex;
for(delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
if (inorder[delimiterIndex] == rootValue) break;
}
// 第四步:切割中序数组(左闭右开)[0,delimiterIndex),[delimiterIndex+1,end)
vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());
// 第五步:切割后序数组,左后序的长度为左中序的长度,右后序的长度为右中序的长度[0,leftInorder.size),(leftInorder.size,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;
}
TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
if (inorder.size() == 0 || postorder.size() == 0) return NULL;
return traversal(inorder, postorder);
}
};