Day16 第六章 二叉树part03 104.二叉树的最大深度 559.n叉树的最大深度111.二叉树的最小深度222.完全二叉树的节点个数

104.二叉树的最大深度 559.n叉树的最大深度
111.二叉树的最小深度
222.完全二叉树的节点个数

104.二叉树的最大深度 559.n叉树的最大深度

思路：递归+前序遍历

每一个”根“ 做一次记录

”叶子“的高度 是 1~！

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (!root) return 0;
        return 1 + max(maxDepth(root->left), maxDepth(root->right));
    }
};

class Solution {
public:
    int getdepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftdepth = getdepth(node->left);       // 左
        int rightdepth = getdepth(node->right);     // 右
        int depth = 1 + max(leftdepth, rightdepth); // 中
        return depth;
    }
    int maxDepth(TreeNode* root) {
        return getdepth(root);
    }
};

多岔口遍历

关键递归： 对每一个岔口进行深度遍历（走遍了每一个岔口）

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == 0) return 0;
        int depth = 0;
        for (int i = 0; i < root->children.size(); i++) {
            depth = max (depth, maxDepth(root->children[i]));
        }
        return depth + 1;
    }
};

111.二叉树的最小深度

避免陷阱NULL

class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftDepth = getDepth(node->left);           // 左
        int rightDepth = getDepth(node->right);         // 右
                                                        // 中
        // 当一个左子树为空，右不为空，这时并不是最低点
        if (node->left == NULL && node->right != NULL) { 
            return 1 + rightDepth;
        }   
        // 当一个右子树为空，左不为空，这时并不是最低点
        if (node->left != NULL && node->right == NULL) { 
            return 1 + leftDepth;
        }
        int result = 1 + min(leftDepth, rightDepth);
        return result;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

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

递归法：前序递归

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

优化法：利用特性（直接比较大子树高度！ 左一定满，右边不一定！）

1.如果它是完全：左大子树，一定是完全！

2.如果不是：直接气急败坏，用老方法return ！ 递归！

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; // 这里初始为0是有目的的，为了下面求指数方便
        while (left) {  // 求左子树深度
            left = left->left;
            leftDepth++;
        }
        while (right) { // 求右子树深度
            right = right->right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

• 时间复杂度：O(log n × log n)
• 空间复杂度：O(log n)