513.找树左下角的值|112. 路径总和|113.路径总和ii |06.从中序与后序遍历序列构造二叉树|105.从前序与中序遍历序列构造二叉树

• 513.找树左下角的值
  • 层次遍历,温故而知新
  • 递归法暂时过

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // void levelFind(TreeNode* p, queue<int>& q) {

    // }
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        que.push(root);
        TreeNode* node;
        while(!que.empty()) {
            node = que.front();
            int size = que.size();
            while (size--) {
                if (que.front() -> left)    que.push(que.front() -> left);
                if (que.front() -> right)   que.push(que.front() -> right);
                que.pop();
            }
        }
        return node -> val;
    }
};

• 112.路径之和(没理解)
  • 与路径之和Ⅱ;
  • 搜索某一路径和搜索整棵树的区别,递归函数有无返回值的情况

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool preOrderPathSum(TreeNode* p, int count) {
        if (!p -> left && !p -> right && count == 0)    return true;
        if (!p -> left && !p -> right)  return false;
        if (p -> left) {
            count -= p -> left -> val;
            if (preOrderPathSum(p -> left, count))  return true;
            count += p -> left -> val;
        }
        if (p -> right) {
            count -= p -> right -> val;
            if (preOrderPathSum(p -> right, count))  return true;
            count += p -> right -> val;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr)    return false;
        return preOrderPathSum(root, targetSum - root -> val);
    }
};

• 精简后

class Solution {
public:
    bool hasPathSum(TreeNode* root, int sum) {
        if (!root) return false;
        if (!root->left && !root->right && sum == root->val) {
            return true;
        }
        return hasPathSum(root->left, sum - root->val) || hasPathSum(root->right, sum - root->val);
    }
};

• 113.路径之和Ⅱ
  • 代码来源:代码随想录

class solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    // 递归函数不需要返回值，因为我们要遍历整个树
    void traversal(TreeNode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) { // 遇到了叶子节点且找到了和为sum的路径
            result.push_back(path);
            return;
        }

        if (!cur->left && !cur->right) 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();                // 回溯
        }
        return ;
    }

public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        result.clear();
        path.clear();
        if (root == NULL) return result;
        path.push_back(root->val); // 把根节点放进路径
        traversal(root, sum - root->val);
        return result;
    }
};

• 106.从中序与后序遍历构造二叉树(待补…)