Day16 二叉树专项 — 递归遍历

LeetCode 513. 找树左下角的值

解题思路：层序遍历找最后一层第一个值

// 迭代（简单）
int findBottomLeftValue(TreeNode* root) {
    queue<TreeNode*> node_q;
    node_q.push(root);
    int ret;

    while(!node_q.empty()) {
        ret = node_q.front()->val;
        int size = node_q.size();
        
        for (int i = 0; i < size; i++) {
            auto tmp = node_q.front();
            node_q.pop();

            if (tmp->left)  node_q.push(tmp->left);
            if (tmp->right)  node_q.push(tmp->right);
        }
    }

    return ret;
}

// 递归（复杂）
class Solution {
public:
    
    void traversal(TreeNode* root, int depth) {
        if (!root->left && !root->right) {
            if (depth > max_depth_) {
                max_depth_ = depth;
                ret_ = root->val;    // 因为递归先访问左侧，所以不同高度第一个点就是该层最左侧的值
            }
        }

        if (root->left) traversal(root->left, depth + 1);
        if (root->right) traversal(root->right, depth + 1);
    }

    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return ret_;
    }

private:
    int max_depth_ = INT_MIN;
    int ret_;
}

LeetCode 112. 路径总和

解题思路：回溯

class Solution {
public:
    // 因为参数不是引用，所以不用对 targetSum 回溯
    bool traversal(TreeNode* root,  int targetSum) {
        targetSum -= root->val;
        if (!root->left && !root->right) {
            return 0 == targetSum ? true : false;
        }

        if (root->left) {
            if (traversal(root->left, targetSum)) {
                return true;
            };
        }
        if (root->right) {
            if (traversal(root->right, targetSum)) {
                return true;
            };
        }

        return false;
    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr) return false;

        return traversal(root, targetSum);
    }
};

LeetCode 113. 路径总和 II

class Solution {
public:
    // 因为参数不是引用，所以不用对 targetSum, path 回溯
    void traversal (TreeNode* root, int targetSum, vector<int> path, vector<vector<int>>& ret) {
        targetSum -= root->val;
        path.push_back(root->val);

        if (!root->left && !root->right) {
            if (0 == targetSum) {
                ret.push_back(path);
            }
            return;
        }

        if (root->left) {
            traversal(root->left, targetSum, path, ret);
        }

        if (root->right) {
            traversal(root->right, targetSum, path, ret);
        }
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>> ret;
        vector<int> path;

        if (root == nullptr) return ret;
        traversal(root, targetSum, path, ret);
        return ret;
    }
};

LeetCode 106. 从中序与后序遍历序列构造二叉树

解题思路：找到中序、后序的左右区间，并分开递归

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if (0 == postorder.size()) return NULL;

        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (1 == postorder.size()) return root;

        int index;
        for (int i = 0; i < inorder.size(); i++) {
            if (inorder[i] == rootValue) {
                index = i;
                break;
            }
        }

        // 左闭右开，[index]元素不要了
        vector<int> left_inorder(inorder.begin(), inorder.begin() + index);
        vector<int> right_inorder(inorder.begin() + index + 1, inorder.end());

        // 左闭右开，最后一个元素不要了
        postorder.resize(postorder.size() - 1);
        vector<int> left_postorder(postorder.begin(), postorder.begin() + left_inorder.size());
        vector<int> right_postorder(postorder.begin() + left_inorder.size(), postorder.end());

        root->left = traversal(left_inorder, left_postorder);
        root->right = traversal(right_inorder, right_postorder);

        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (0 == inorder.size() || 0 == postorder.size()) return NULL;
        return traversal(inorder, postorder);
    }
};