代码随想录刷题记录（12）| 二叉树（226.翻转二叉树，101. 对称二叉树，104.二叉树的最大深度，111.二叉树的最小深度）-CSDN博客

/**
 * 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 {
private:
    void Invert(TreeNode* root) {
        if(!root)   return;
        TreeNode* temp = root->left;
        root->left = root->right;
        root->right = temp;
        Invert(root->left);
        Invert(root->right);
    }

public:
    TreeNode* invertTree(TreeNode* root) {
        Invert(root);
        return root;
    }
};

（七）对称二叉树

101. 对称二叉树 - 力扣（LeetCode）

1. 题目描述

给你一个二叉树的根节点 root ，检查它是否轴对称。

2. 思路

（1）递归法

① 确定递归函数的参数和返回值

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。返回值自然是bool类型。

② 确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

左节点为空，右节点不为空，不对称，return false
左不为空，右为空，不对称 return false
左右都为空，对称，返回true

此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

左右都不为空，比较节点数值，不相同就return false

此时左右节点不为空，且数值也不相同的情况我们也处理了。

③ 确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理左右节点都不为空，且数值相同的情况。

比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
如果左右都对称就返回true ，有一侧不对称就返回false 。

使用的遍历方式，左子树左右中，右子树右左中。

（2）迭代法

用队列（或者栈）比较对称节点处是否相等（成对的取出就行），先把左右节点加进去，然后比较，如果相等，则再依次加入左节点左孩子、右节点右孩子、左节点右孩子、右节点左孩子。

3. 解题过程

难易程度：简单

标签：树、深度优先搜索、广度优先搜索、二叉树

class Solution {
private:
    bool Compare(TreeNode* left, TreeNode* right) {
        // 一边空一边非空
        if(left && !right)  return false;
        else if(!left && right) return false;
        // 两边都空
        else if(!left && !right)    return true;
        // 两边都非空但数值不相等
        else if(left->val != right->val)    return false;
        // 比较内外侧
        bool inside = Compare(left->right, right->left);
        bool outside = Compare(left->left, right->right);
        return inside && outside;
    }

public:
    bool isSymmetric(TreeNode* root) {
        if(!root)   return true;
        return Compare(root->left, root->right);
    }
};

（八）二叉树的最大深度

1. 思路

上一篇用迭代层序遍历写完了，递归的思路如下：

后序遍历（左右中）来计算树的高度。

确定递归函数的参数和返回值：参数就是传入树的根节点，返回就返回这棵树的深度，所以返回值为int类型。
确定终止条件：如果为空节点的话，就返回0，表示高度为0。
确定单层递归的逻辑：先求它的左子树的深度，再求右子树的深度，最后取左右深度最大的数值再+1 （加1是因为算上当前中间节点）就是目前节点为根节点的树的深度。

2. 相关题目

559. N 叉树的最大深度 - 力扣（LeetCode）

（1）题目描述

给定一个 N 叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔。

（2）思路

和二叉树一样，递归迭代两种。

（3）解题过程

难易程度：简单

标签：树、深度优先搜索、广度优先搜索

① 递归

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

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

② 迭代

class Solution {
public:
    int maxDepth(Node* root) {
        queue<Node*> que;
        if(root)   que.push(root);
        int result = 0;
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                for(int j = 0; j < node->children.size(); j++) {
                    que.push(node->children[j]);
                }
            }
            result++;
        }
        return result;
    }
};

（九）二叉树的最小深度

上一篇用迭代层序遍历写完了，递归的思路如下：

确定递归函数的参数和返回值：参数为要传入的二叉树根节点，返回的是int类型的深度。
确定终止条件：终止条件也是遇到空节点返回0，表示当前节点的高度为0。
确定单层递归的逻辑：如果左子树为空，右子树不为空，说明最小深度是 1 + 右子树的深度。反之，右子树为空，左子树不为空，最小深度是 1 + 左子树的深度。最后如果左右子树都不为空，返回左右子树深度最小值 + 1 。