[代码随想录算法训练营]刷题笔记 Day 18

513.找树左下角的值

遞迴

class Solution {
public:
    // 全局變量
    int maxDepth = INT32_MIN;
    int result;

    void traverse(TreeNode* node, int depth){
        // 終止條件
        // 若沒有左右子結點，那麼我們必須判斷他是不適最深的一層(判斷條件不能 >= ，因為只更新最左邊的，如果有等號則同一層右邊的也會更新進去)
        if(!node->left && !node->right){
            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--;
        }
    }
    int findBottomLeftValue(TreeNode* root) {
        if(!root) return result;

        traverse(root, 0);

        return result;
    }
};

迭戴

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; // 记录最后一行第一个元素
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return result;
    }
};

112. 路径总和

class Solution {
public:
	bool traversal(TreeNode* cur, int count) {
		if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
		if (!cur->left && !cur->right) 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);
    }
};

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

// 利用后序数组来确认当前层的中间节点
// 利用刚刚找到的中间节点，切割中序数组
// 利用中序数组，来切割后序数组
// 结束当曾逻辑，递归至下一层。左子树就传入左中序及左后序数组，反之亦然。
// 返回当前层节点
class Solution {
private:
    TreeNode* traverse(vector<int>& inorder, vector<int>& postorder){
        // 检查空数组
        if(inorder.size() == 0) return nullptr;

        // 找寻当前根结点，并创建
        int val = postorder[postorder.size() - 1];
        TreeNode* cur = new TreeNode(val);
        // 如果数组只有他一个节点，说明是叶结点，直接返回
        if(postorder.size() == 1) return cur;

        // 切割中序数组，找到左子树集合和右子树集合
        int index = 0;
        for(; index < inorder.size(); index++){
            if(inorder[index] == val) break;
        }

        // 构建左子树
        vector<int> leftInorder(inorder.begin(), inorder.begin() + index);
        vector<int> rightInorder(inorder.begin() + index + 1, inorder.end());

        // 去除最后一个节点，当前的节点
        postorder.resize(postorder.size() - 1);
        // 构建右子树
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        cur->left = traverse(leftInorder, leftPostorder);
        cur->right = traverse(rightInorder, rightPostorder);

        return cur;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traverse(inorder, postorder);
    }
};