代码随想录算法训练营第十三天 | 226.翻转二叉树、101.对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度

1.翻转二叉树：

/**

 * 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:

    TreeNode* invertTree(TreeNode* root) {

        if (root == NULL) return root;

        stack<TreeNode*> st;

        st.push(root);

        while(!st.empty()){

            TreeNode* node = st.top();

            st.pop();

            swap(node -> left, node -> right);

            if (node -> right) st.push(node -> right);

            if (node -> left) st.push(node -> left);

        }

        return root;

    }

};

## 递归法

class Solution {

public:

    TreeNode* invertTree(TreeNode* root) {

        if (root == NULL) return root;

        swap(root -> left, root-> right);

        invertTree(root -> left);

        invertTree(root -> right);

        return root;

    }

};

2. 对称二叉树：

## 递归法

class Solution {

public:

    bool compare(TreeNode* left, TreeNode* right) {

        // 首先排除空节点的情况

        if (left == NULL && right != NULL) return false;

        else if (left != NULL && right == NULL) return false;

        else if (left == NULL && right == NULL) 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 == NULL) return true;

        return compare(root->left, root->right);

    }

};

3. 二叉树最大深度

## 递归法

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

    }

};

4.二叉树最小深度

## 递归法

## 这里与最大深度不同，虽是后序遍历但要注意最后处理的逻辑

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

    }

};