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

226. 翻转二叉树

226. 翻转二叉树

递归法

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return nullptr;
        }
        TreeNode* right = invertTree(root->left); //左
        TreeNode* left = invertTree(root->right); //右
        //后序遍历
        root->left = left; //中
        root->right = right; 
        return root;
    }
};

迭代 前序遍历

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return nullptr;
        }
        stack<TreeNode*> stk;
        stk.push(root);
        while (!stk.empty()) {
            TreeNode* cur = stk.top();
            stk.pop();
            swap(cur->left, cur->right); // 交换当前节点的左右子节点 前序遍历
            if (cur->right) {
                stk.push(cur->right);
            }
            if (cur->left) {
                stk.push(cur->left);
            }
        }
        return root;
    }
};

广度优先遍历

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) {
            return nullptr;
        }
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size) {
                TreeNode* cur = que.front();
                que.pop();
                --size;
                swap(cur->left, cur->right); // 交换左右子节点
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
            }
        }
        return root;
    }
};

101. 对称二叉树

101. 对称二叉树
根节点的左右子树是否可以相互翻转；

递归法

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if (left == nullptr && right != nullptr) {
            return false;
        } else if (left != nullptr && right == nullptr) {
            return false;
        } else if (left == nullptr && right == nullptr) {
            return true;
        } else if (left->val != right->val) {
            return false;
        }
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        bool isSame = outside && inside;
        return isSame;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) {
            return true;
        }
        return compare(root->left, root->right);
    }
};

100.相同的树

100.相同的树

class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (p == nullptr && q == nullptr) {
            return true;
        } else if (p != nullptr && q == nullptr) {
            return false;
        } else if (p == nullptr && q != nullptr) {
            return false;
        } else if (p->val != q->val) {
            return false;
        }
        return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }
};

572.另一个树的子树

class Solution {
public:
    // 判断两棵树是否相同
    bool isSame(TreeNode* root, TreeNode* subRoot) {
        if (root == nullptr && subRoot == nullptr) {
            return true;
        } else if (root != nullptr && subRoot == nullptr) {
            return false;
        } else if (root == nullptr && subRoot != nullptr) {
            return false;
        } else if (root->val != subRoot->val) {
            return false;
        }
        return isSame(root->left, subRoot->left) &&
                isSame(root->right, subRoot->right);
    }
    bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        if(subRoot == nullptr) { 
            return true; 
        }
        if (root == nullptr) {
            return false;
        }
        //判断当前root与subRoot是否相同，
        //如果不相同，判断root的左或右子树与subRoot是否相同
        return isSame(root, subRoot) ||
               isSubtree(root->right, subRoot) ||
               isSubtree(root->left, subRoot);
    }
};

二叉树的深度和高度

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）

104.二叉树的最大深度

104.二叉树的最大深度

递归法

根节点的高度就是二叉树的最大深度；
后序遍历 求 跟节点的高度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        int leftHeight = maxDepth(root->left);
        int rightHeight = maxDepth(root->right);
        int height = max(leftHeight, rightHeight) + 1;
        return height;
        //return max(maxDepth(root->left),maxDepth(root->right)) + 1;
    }
};

广度优先遍历

计算二叉树的最大深度即计算二叉树的层数；

class Solution {
public:
    int maxDepth(TreeNode* root) {
        int depth = 0;
        if (root == nullptr) {
            return 0;
        }
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();
            while (size) {
                TreeNode* cur = que.front();
                que.pop();
                if (cur->left) {
                    que.push(cur->left);
                }
                if (cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            ++depth; 
        }
        return depth;
    }
};

111.二叉树的最小深度

111.二叉树的最小深度
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

递归法

同104计算根节点的最小高度，注意左右子字节一方为空的情况。

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

广度优先遍历

叶子节点所在的层数即为它的深度，层序遍历可以保证最先访问到的叶子节点深度最小，即整棵二叉树的最小深度。

class Solution {
public:
    int minDepth(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        queue<TreeNode*> que;
        int res = 1; //根节点不为空，深度初始值设为 1
        que.push(root);
        while(!que.empty()) {
            TreeNode* cur = nullptr;
            int size = que.size();
            while (size) {
                cur = que.front();
                que.pop();
                if(cur->left == nullptr && cur->right == nullptr) {
                    return res; //是叶子节点，返回它的深度
                }
                if(cur->left) {
                    que.push(cur->left);
                }
                if(cur->right) {
                    que.push(cur->right);
                }
                --size;
            }
            ++res;
        }
        return res;
    }
};

559. N 叉树的最大深度

559. N 叉树的最大深度

广度优先遍历-层序遍历

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == nullptr) {
            return 0;
        }
        queue<Node*> que;
        que.push(root);
        int res = 0;
        while (!que.empty()) {
            int size = que.size();
            ++res; // 更新深度
            while (size) {
                Node* cur = que.front();
                que.pop();
                --size;
                // 如果计算最小深度就要判断当前节点是否为叶子节点
                // 将当前节点的所有叶子节点压入队列
                for (Node* node : cur->children) {
                    que.push(node);
                }
            }
        }
        // N 叉树的层数即为最大深度
        return res;
    }
};

递归法

class Solution {
public:
    int maxDepth(Node* root) {
        if (root == nullptr) {
            return 0;
        }
        int getDepth = 0;
        for(Node* node : root->children) {
            getDepth = max(getDepth, maxDepth(node));
        }
        return getDepth + 1;
    }
};