算法训练（leetcode）第十三天 | 110. 平衡二叉树、257. 二叉树的所有路径、404. 左叶子之和、222. 完全二叉树的节点个数

110. 平衡二叉树

leetcode题目地址

使用计算树的最大高度的代码来改，当出现左右子树深度的差值大于1则不是平衡树。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c++
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countLevel(TreeNode* root){
        if(!root) return 0;
        int left = countLevel(root->left);
        if(left==-1) return -1;
        int right = countLevel(root->right);
        if(right==-1) return -1;
        return fabs(left-right)>1?-1:max(left, right)+1;
    }
    
    bool isBalanced(TreeNode* root) {
        return countLevel(root)==-1?false:true;
    }
};

257. 二叉树的所有路径

leetcode题目地址

使用递归求解，递归出口为叶结点，path记录从根节点到当前节点的路径，vc记录结果。

• 当前结点为叶结点时， 在path后加上当前节点值，存入结果列表，回退。
• 只访问非空节点。一般情况下使用节点值加箭头，业结点后边不需要加箭头。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c++
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void preOrder(TreeNode* root, vector<string>& vc, string path){
        
        if(!root->left && !root->right) {
            path += to_string(root->val);
            vc.emplace_back(path);
            return;
        }
        
        path += to_string(root->val) + "->";

        if(root->left)
        preOrder(root->left, vc, path);
        if(root->right)
        preOrder(root->right, vc, path);
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> vc;
        preOrder(root, vc, "");
        return vc;
    }
};

404. 左叶子之和

leetcode题目地址

使用遍历的代码来改。当前节点是叶结点且是左孩子时，将其val值加入结果sum。在函数参数中加一个bool值来标记左右孩子。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c++
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void preOrder(TreeNode* root, int &sum, bool isLeft){

        if(!root->left && !root->right && isLeft) {
            sum += root->val;
            return;
        }
        
        if(root->left){
            preOrder(root->left, sum, true);
        }
        if(root->right){
            preOrder(root->right, sum, false);
        }
        
    }
    int sumOfLeftLeaves(TreeNode* root) {
        int sum = 0;
        preOrder(root, sum, false);
        return sum;
    }
};

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

leetcode题目地址

• 方法一：遍历过程中计算访问过的节点数。

• 方法二：当二叉树使用数组存储时，$N$个结点的二叉树最后一个非叶结点的下标为：$$\lfloor N/2\rfloor$$利用这一性质，使用层序遍历，找最后一个非叶结点来计算。

  当最后一个非叶结点左右孩子都有时，则总结点数为：非叶结点个数 * 2 + 1；

  当最后一个非叶结点只有左孩子时，总结点数为：非叶结点个数 * 2。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

方法一：遍历计数

// c++
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void Order(TreeNode* root, int &cnt){
        if(!root) return;
        cnt++;
        Order(root->left, cnt);
        Order(root->right, cnt);
    }
    int countNodes(TreeNode* root) {
        int cnt=0;
        Order(root, cnt);
        return cnt;
    }
};

方法二：完全二叉树性质

// c++
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(!root) return 0;
        queue<TreeNode*> qu;
        int cnt=0;
        qu.push(root);
        while(!qu.empty()){
            int size = qu.size();
            for(int i=0; i<size; i++){
                root = qu.front();
                cnt++;
                qu.pop();
                // 当前节点是第一个叶结点 且前一个结点（最后一个非叶结点）左右孩子都有
                if(!root->left) return 2 * cnt - 1;
                qu.push(root->left);
                // 当前节点是最后一个非叶结点 且有左孩子
                if(!root->right) return 2*cnt;
                qu.push(root->right); 
            }
        }
        return cnt;        
    }
};