【代码随想录_Day12】 110 平衡二叉树 257 二叉树的所有路径 404 左叶子之和 222 完全二叉树的节点个数

以下是今日份的总结

110 平衡二叉树
257 二叉树的所有路径
404 左叶子之和
222 完全二叉树的节点个数

110 利用层序遍历，和递归的方式计算深度，在迭代法的层序遍历中进行判断

257 初步涉及到回溯的思想，用前序遍历的方式去探寻深度

404 通过层序遍历，将左叶子节点筛选出来再求和

222 遍历二叉树的同时对节点计数

今天的题目全是easy题，做完直接大记忆恢复术，遍历全部想起，递归也想起来了 ^ _ ^

平衡二叉树

思路：

平衡二叉树 是指该树所有节点的左右子树的深度相差不超过 1。

值得注意的是

abs() 返回一个参数的绝对值

    int height(TreeNode* node){
        if(node==nullptr)return 0;
        return 1+max(height(node->left), height(node->right));
    }
    bool isBalanced(TreeNode* root) {
        if(root==nullptr)return true;
        queue<TreeNode*>que;
        que.push(root);
        while(!que.empty()){
            for(int i = 0;i<que.size();i++){
                TreeNode* node = que.front();
                que.pop();
                
                int leftHeight = height(node->left);
                int rightHeight = height(node->right);

                //平衡二叉树 是指该树所有节点的左右子树的深度相差不超过 1。
                if(abs(leftHeight-rightHeight)>1)return false;

                if(node->left)que.push(node->left);
                if(node->right)que.push(node->right);

            }
        }
        return true;

二叉树的所有路径

思路:

初步涉及到回溯的思想，用前序遍历的方式去探寻深度

值得注意的是

要针对左右子树和叶节点做判断

    void road(TreeNode* node,vector<int> &path, vector<string> &res){
        //前序遍历，中
        path.push_back(node->val);//将当前节点加入路径集
        //左
        if(node->left){
            road(node->left, path, res);
            path.pop_back();//回溯
        }
        if(node->right){
            road(node->right, path, res);
            path.pop_back();//回溯           
        }
        if(node->left==NULL&&node->right==NULL){
            string sPath;
            for(int i = 0;i<path.size()-1;i++){
                sPath +=to_string(path[i]);
                sPath += "->";
            }
            sPath +=to_string(path[path.size()-1]);
            res.push_back(sPath);//记录路径
            return;
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        if(root==NULL)return vector<string>();
        vector<string>res;
        vector<int>path;
        road(root, path, res);
        return res;
    }

左叶子之和

思路:

通过层序遍历，将左叶子节点筛选出来再求和

值得注意的是

判断中注意将右叶子节点排除

    int sumOfLeftLeaves(TreeNode* root) {
        if(root==0)return 0;
        if(root->left==nullptr&&root->right==nullptr)return 0;
        int res = 0;
        vector<int> vec;
        queue<TreeNode*>que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            for(int i = 0;i<size;i++){
                TreeNode* tmp  = que.front();
                que.pop();
                
                if(tmp->left==nullptr&&tmp->right==nullptr){
                    vec.push_back(tmp->val);
                }
                if(tmp->left)que.push(tmp->left);
                if(tmp->right){
                    TreeNode* tn = tmp->right;
                    
                    if(tn->right==NULL&&tn->left==NULL){
                        continue;
                    }
                    que.push(tn);
                }
            }
        }
        for(int i:vec){
            res+=i;
        }
        return res;
    }

完全二叉树的节点个数

思路:

遍历二叉树的同时对节点计数

值得注意的是

这里是用的一般方法，涵盖了完全二叉树

    //前序遍历递归时统计递归次数
    void preOrder(TreeNode* node,int &sum){
        if(node==NULL)return;
        sum++;
        preOrder(node->left, sum);
        preOrder(node->right, sum);
    }
    int countNodes(TreeNode* root) {
        int res = 0;
        preOrder(root, res);
        return res;
    }

写在最后

----OK，今日份的博客就写到这里，这一期的题全是基础操作，明天继续加油！！！
—看了看下期的题，以后的二叉树就没这么轻松了；
–追上时间进度了吗？如追，从欠三天变成欠两天！！（笑
-我们一起为未来干杯🍻。