代码随想录算法训练营第十五天 | 二叉树3

1、平衡二叉树
主要是看左右高度只差，深度是从root往下看，高度是从最下面往上看，还是看成深度比较好理解，说白了就是左右的深度差不能超过1，求出来最大深度后再比较就好了
递归：
 

class Solution {
    int getDepth(TreeNode* node)
    {
        if(node == nullptr) return 0;
        int leftDepth = getDepth(node->left);
        int rightDepth = getDepth(node->right);
        if(leftDepth == -1 || rightDepth == -1) return -1;
        if(abs(leftDepth-rightDepth)>1) return -1;
        return 1+max(leftDepth,rightDepth);
    }
public:
    bool isBalanced(TreeNode* root) {
        int depth = getDepth(root);
        if(depth == -1) return false;
        return true;

    }
};

迭代：被覆盖了...

2、二叉树的所有路径，这个题右坑的，仔细思考什么时候加引用，什么时候不加，不加引用的时候往往有回溯的作用，不加引用每次一个新的递归就会刷新path，但注意在一轮递归调用中，path是增加的，只有重新开始递归才刷新
 

class Solution {
private:
    vector<int> path;
    vector<string> result;
public:
    void travalSal(TreeNode* node, vector<int>& path, vector<string>& result) {
        if (node == nullptr)
            return;
        path.push_back(node->val);
        if(node->left == nullptr && node->right==nullptr)
        {
            string tmp="";
            for(int i = 0;i<path.size()-1;i++)
            {
                tmp+=to_string(path[i]);
                tmp+="->";
            }
            tmp+=to_string(path[path.size()-1]);
            result.push_back(tmp);
            return;
        }

        if(node->left) 
        {
            travalSal(node->left,path,result);
            path.pop_back();
        }
        if(node->right)
        {
            travalSal(node->right,path,result);
            path.pop_back();
        }

    }
    vector<string> binaryTreePaths(TreeNode* root) {
        travalSal(root,path,result);
        return result;
    }
};

class Solution {
private:
    string path;
    vector<string> result;

public:
    void trvalSal(TreeNode* node, string path, vector<string>& result) {
        if(node==nullptr) return;

        path += to_string(node->val);
        if (node->left == nullptr && node->right == nullptr) {
            result.push_back(path);
            return;
        }
        path += "->";
        if (node->left) {
            trvalSal(node->left, path, result);
        
        }
        if (node->right) {
            trvalSal(node->right, path, result);
        
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        trvalSal(root, path, result);
        return result;
    }
};

3、左子叶之和
主要考查如何判断满足条件的叶子，一个叶子是左还是右只能由他·的父节点决定，所以判断的维度是父节点：
迭代：
 

class Solution {
private:
vector<int> result;
public:
    int sumOfLeftLeaves(TreeNode* root) {
    if(!root) return 0;
    stack<TreeNode*> st;
    st.push(root);

    while(!st.empty())
    {
        TreeNode* tmp = st.top();
        st.pop();
        if(tmp->left && !tmp->left->left && !tmp->left->right)
        {
            result.push_back(tmp->left->val);
        }
        if(tmp->left) st.push(tmp->left);
        if(tmp->right) st.push(tmp->right);
    }
    return accumulate(result.begin(),result.end(),0);


    }
};

递归：

public:

    void getLeft(TreeNode* node,vector<int> &leftContainer)
    {
        if(node == nullptr) return;
        if(node->left && !node->left->left && !node->left->right)
        {
            leftContainer.push_back(node->left->val);
        }
        if(node->left) getLeft(node->left,leftContainer);
        if(node->right) getLeft(node->right,leftContainer);
    }
    int sumOfLeftLeaves(TreeNode* root) {
        getLeft(root,leftContainer);
        return accumulate(leftContainer.begin(),
        leftContainer.end(),0);           

    }
};

4、最后一层左下角的值
这个题用层序很简单，只需要保存最后一层的第一个值就好了，用递归反而难，主要是要记录最后一层的最左边的那个值，可以用一个深度值做标记，当第一次到最深的时候的就是我们遍历要的值的时候

递归：

class Solution {
private:
    int maxDepth = -1;  // 初始化为 -1，因为深度从 0 开始
    int result;         // 记录结果

public:
    void getLeft(TreeNode* node, int depth) {
        if (node == nullptr) return;

        // 更新结果值和最大深度
        if (depth > maxDepth) {
            maxDepth = depth;
            result = node->val;
        }

        // 先递归左子树
        if (node->left) {
            getLeft(node->left, depth + 1);
        }
        
        // 再递归右子树
        if (node->right) {
            getLeft(node->right, depth + 1);
        }
    }

    int findBottomLeftValue(TreeNode* root) {
        if (root == nullptr) return -1;
        getLeft(root, 0);  // 从深度 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;
    }
};