代码随想录算法训练营 | 二叉树part03

110.平衡二叉树

https://leetcode.cn/problems/balanced-binary-tree/description/
给定一个二叉树，判断它是否是 平衡二叉树（该树所有节点的左右子树的深度相差不超过 1 ）

class Solution {
public:
    // 返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树了则返回-1
    int getHeight(TreeNode* node) { 
        if (node == NULL) {
            return 0;
        }
        int leftHeight = getHeight(node->left); // 计算左子树的最大高度
        if (leftHeight == -1) return -1;
        int rightHeight = getHeight(node->right); // 计算右子树的最大高度
        if (rightHeight == -1) return -1;
        return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};

257. 二叉树的所有路径

257. 二叉树的所有路径

class Solution {
public:
    void traversal(TreeNode* node, vector<int>& path, vector<string>& res) {
        //由于递归的终止条件是遍历到叶子节点结束，我们应该向存储节点值，保证叶子节点可以被加到path中
        path.push_back(node->val); //中 
        //递归中止条件的判断
        if (node->left == nullptr && node->right == nullptr) {
            //遍历到叶子节点
            string s;
            for (int i = 0; i < path.size() - 1; ++i) {
                s += to_string(path[i]);
                s += "->";
            }
            s += to_string(path[path.size() - 1]);
            res.push_back(s);
        }
        if (node->left) { //遍历左子树
            traversal(node->left, path, res);
            path.pop_back(); //回退到node的阶段 回溯
        }
        if (node->right) { //遍历右子树
            traversal(node->right, path, res);
            path.pop_back(); //回退到node的阶段 回溯
        }

    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> res;
        traversal(root, path, res);
        return res;
    }
};

404.左叶子之和

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        // 通过节点的父节点来判断其左孩子是不是左叶子
        if (root->left == nullptr && root->right== nullptr) {
            return 0;
        }
        int leftValue = sumOfLeftLeaves(root->left);    // 左
        if (root->left && !root->left->left && !root->left->right) { // 左子树就是一个左叶子的情况
            leftValue = root->left->val;
        }
        int rightValue = sumOfLeftLeaves(root->right);  // 右

        int sum = leftValue + rightValue;               // 中
        return sum;
    }
};

222.完全二叉树的节点个数

222.完全二叉树的节点个数
对于普通二叉树：遍历二叉树来计算节点个数；代码同二叉树的前序/中序/后序/层序遍历

前序遍历

class Solution {
public:
	//前序遍历
    void traversal(TreeNode* root, int& cnt) {
        if (root == nullptr) {
            return;
        }
        ++cnt; // 中
        traversal(root->left, cnt); // 左
        traversal(root->right, cnt);  // 右
    }
    int countNodes(TreeNode* root) {
        int cnt = 0;
        traversal(root, cnt);
        return cnt;
    }
};

后序遍历

class Solution {
public:	
    int countNodes(TreeNode* root) {
        if (root == nullptr) {
        	return 0;
        }
        int leftCnt = countNodes(root->left);
        int rightCnt = countNodes(root->right);
        return leftCnt + rightCnt + 1;
    }
};

利用完全二叉树的特性

除了最底层节点没填满外，其余每层节点数都达到最大值，并且最后一层的节点都集中在该层最左边的若干位置；
完全二叉树中的节点的左右子树，要么都是满二叉树，要么一颗是满二叉树，一颗是完全二叉树；

class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == nullptr) {
            return 0;
        }
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int leftDepth = 0, rightDepth = 0;
        while (left) { // 求左子树深度
            left = left->left;
            leftDepth++;
        }
        while (right) { //求右子树深度
            right = right->right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            // 是一颗满二叉树
            return (2 << leftDepth) - 1; 
            // 这里的深度我们计算的子树的深度，那么整棵树的深度为 leftDepth + 1             
            // 满二叉树节点个数公式为 2 ^ (leftDepth + 1) -1
            // 位运算 2 << leftDepth，相当于 2 ^ (leftDepth + 1)
        }
        int leftCnt = countNodes(root->left);
        int rightCnt = countNodes(root->right);
        return leftCnt + rightCnt + 1;
    }
};