代码随想录刷题 Day18

513.找树左下角的值

这个题用层序遍历比较简单，按照模版改一句话就可以；层序遍历用这个queue来实现；

用前序遍历的话就需要用递归比较麻烦

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        int result = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
  		        if (i == 0) result = node->val; // 记录最后一行第一个元素; 这里自己理解错了，这个题的size是就是每行有几个数字，当size是零的时候就是一排的第一个元素，这个数值会一直更替直到最后一次
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

LeetCode：112. 路径总和

class Solution {
private:
    bool traversal(TreeNode* cur, int count) {
        if (cur->left == NULL && cur->right == NULL && count == 0) return true; // 遇到叶子节点，并且计数为0
        //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; //注意每一次递归都会往上传递一次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;
    }

public:
    bool hasPathSum(TreeNode* root, int sum) {
        if (root == NULL) return false;
        return traversal(root, sum - root->val);
    }
};

113. Path Sum II

和上一个题的区别主要在于递归函数返回值

class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    void traversal(TreeNode* cur, int count) {
        if (cur->left == NULL && cur->right == NULL && count == 0)
        {result.push_back(path);
        return;
        }
        if (cur->left == NULL && cur->right == NULL && count == 0)
        {result.push_back(path);
        return;
        }
        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();                // 回溯
        }
    }

public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        result.clear();
        path.clear();
        if(root == NULL) return result;
        path.push_back(root->val);
        traversal(root, targetSum - root->val);
        return result;
    }
};