力扣题解 二叉树（5）

559.n叉树的最大深度

总结：
比较自己的孩子， maxdepth(root->children[i]));

递归法

c++代码：

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;
    }
};

依然是层序遍历，代码如下：

class solution {
    
public:
    int maxdepth(node* root) {
    
        queue<node*> que;
        if (root != NULL) que.push(root);
        int depth = 0;
        while (!que.empty()) {
    
            int size = que.size();
            depth++; // 记录深度
            for (int i = 0; i < size; i++) {
    
                node* node = que.front();
                que.pop();
                for (int j = 0; j < node->children.size(); j++) {
    
                    if (node->children[j]) que.push(node->children[j]);
                }
            }
        }
        return depth;
    }
};

111.二叉树的最小深度

总结：
最小深度，肯定有一个缺左右孩子。

如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度。

反之，右子树为空，左子树不为空，最小深度是 1 + 左子树的深度。 最后如果左右子树都不为空，返回左右子树深度最小值 + 1

递归法：

 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);
        }
    };
    

迭代法：

层序遍历， 左右孩子都为空就是最低点。

class Solution {
    
public:

    int minDepth(TreeNode* root) {
    
        if (root == NULL) return 0;
        int depth = 0;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()) {
    
            int size = que.size();
            depth++; // 记录最小深度
            for (int i = 0; i < size; i++) {
    
                TreeNode* node = que.front();
                que.pop();
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
                if (!node->left && !node->right) {
     // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                    return depth;
                }
            }
        }
        return depth;
    }
};

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

总结：

• 时间复杂度：O(n)
• 空间复杂度：O(log n)，算上了递归系统栈占用的空间

    class Solution {
    
    private:
        int getNodesNum(TreeNode* cur) {
    
            if (cur == NULL) return 0;
            int leftNum = getNodesNum(cur->left);      // 左
            int rightNum = getNodesNum(cur->right);    // 右
            int treeNum = leftNum + rightNum + 1;      // 中
            return treeNum;
        }
    public:
        int countNodes(TreeNode* root) {
    
            return getNodesNum(root);
        }
    };

迭代

    class Solution {
    
    public:
        int countNodes(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();
                    result++;   // 记录节点数量
                    if (node->left) que.push(node->left);
                    if (node->right) que.push(node->right);
                }
            }
            return result;
        }
    };

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

满二叉树递归，一个节点也是满二叉树。

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

利用二叉树的性质求的

class Solution {
    
public:
    int countNodes(TreeNode* root) {
    
        if (root == nullptr) return 0;
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int leftHeight = 0, rightHeight = 0; // 这里初始为0是有目的的，为了下面求指数方便
        while (left) {
      // 求左子树深度
            left = left->left;
            leftHeight++;
        }
        while (right) {
     // 求右子树深度
            right = right->right;
            rightHeight++;
        }
        if (leftHeight == rightHeight) {
    
            return (2 << leftHeight) - 1; // 注意(2<<1) 相当于2^2，所以leftHeight初始为0
        }
        return countNodes(root->left) + countNodes(root->right) + 1;
    }
};

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

110.平衡二叉树

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过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;
        }
    };

时间复杂度：O(n)，其中 n 是二叉树中的节点个数。使用自底向上的递归，每个节点的计算高度和判断是否平衡都只需要处理一次，最坏情况下需要遍历二叉树中的所有节点，因此时间复杂度是 O(n)O(n)。

空间复杂度：O(n)，其中 n 是二叉树中的节点个数。空间复杂度主要取决于递归调用的层数，递归调用的层数不会超过 n。

257.二叉树的所有路径

总结：

    class Solution {
    
    private:
    
        void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {
    
            path.push_back(cur->val);
            // 这才到了叶子节点
            if (cur->left == NULL && cur->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]);
                result.push_back(sPath);
                return;
            }
            if (cur->left) {
    
                traversal(cur->left, path, result);
                path.pop_back(); // 回溯
            }
            if (cur->right) {
    
                traversal(cur->right, path, result);
                path.pop_back(); // 回溯
            }
        }
    
    public:
        vector<string> binaryTreePaths(TreeNode* root) {
    
            vector<string> result;
            vector<int> path;
            if (root == NULL) return result;
            traversal(root, path, result);
            return result;
        }
    };



迭代：

    class Solution {
    
    public:
        vector<string> binaryTreePaths(TreeNode* root) {
    
            stack<TreeNode*> treeSt;// 保存树的遍历节点
            stack<string> pathSt;   // 保存遍历路径的节点
            vector<string> result;  // 保存最终路径集合
            if (root == NULL) return result;
            treeSt.push(root);
            pathSt.push(to_string(root->val));
            while (!treeSt.empty()) {
    
                TreeNode* node = treeSt.top(); treeSt.pop(); // 取出节点 中
                string path = pathSt.top();pathSt.pop();    // 取出该节点对应的路径
                if (node->left == NULL && node->right == NULL) {
     // 遇到叶子节点
                    result.push_back(path);
                }
                if (node->right) {
     // 右
                    treeSt.push(node->right);
                    pathSt.push(path + "->" + to_string(node->right->val));
                }
                if (node->left) {
     // 左
                    treeSt.push(node->left);
                    pathSt.push(path + "->" + to_string(node->left->val));
                }
            }
            return result;
        }
    };