【leetcode题解C++】101.对称二叉树 and 111.二叉树的最小深度 and 222.完全二叉树的节点个数 and 110.平衡二叉树

101. 对称二叉树

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

示例 1：

输入：root = [1,2,2,3,4,4,3]
输出：true

示例 2：

输入：root = [1,2,2,null,3,null,3]
输出：false

思路：想到了用队列（迭代），把每一对结点入队，判定的条件有val的值是否相等，还有某某结点是否存在，需要注意的是入队的顺序，要符合对称的判定。leetcode官方题解也有一种递归的方法，代码很简短，下面也会给出。

代码实现1：迭代

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode *> que;
        que.push(root->left);
        que.push(root->right);
        while(!que.empty()) {
            TreeNode *node1 = que.front(); que.pop();
            TreeNode *node2 = que.front(); que.pop();
            if(!node1 && !node2) continue;
            if(!node1 || !node2 || node1->val != node2->val) return false;
            que.push(node1->left);
            que.push(node2->right);
            que.push(node1->right);
            que.push(node2->left);
        }
        return true;
    }
};

代码实现2：递归

class Solution {
public:
    bool check(TreeNode *p, TreeNode *q) {
        if (p==nullptr && q==nullptr) return true;
        if (p==nullptr || q==nullptr) return false;
        return p->val == q->val && check(p->left, q->right) && check(p->right, q->left);
    }
    bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
};

111. 二叉树的最小深度（最大深度类似）

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：2

示例 2：

输入：root = [2,null,3,null,4,null,5,null,6]
输出：5

思路：用一个队列层序遍历即可，return的时机是：出现第一个节点，它的左右孩子都为空。（如果是记录最大深度，把这个中途return的判定去掉即可）

代码实现：

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode *> que;
        int depth = 0;
        if(!root) return depth;
        que.push(root);
        TreeNode *node;
        while(!que.empty()) {
            int size = que.size();
            ++depth;
            for(int i = 0; i < size; ++i) {
                node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                if(!node->right && !node->left) return depth; //中途判定
            }
        }
        return depth;
    }
};

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

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例 1：

输入：root = [1,2,3,4,5,6]
输出：6

示例 2：

输入：root = []
输出：0

示例 3：

输入：root = [1]
输出：1

思路：注意到，完全二叉树，那么使用队列来层序遍历即可，用ret来记录节点数，每多一个节点，ret++。

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode *> que;
        int ret = 0;
        if(!root) return ret;
        que.push(root);
        TreeNode *node;
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i< size; ++i) {
                node = que.front();
                que.pop();
                ++ret;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return ret;
    }
};

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

思路：一开始就想用层序遍历记录最小和最大深度，然后来相减，后来一想要是二叉树是只有一支的话，实现不了，单独判定也不好判定。遂学习...，找到了递归的方法，判断每一个节点的左右子树是否为平衡的。

代码实现：

class Solution {
public:
    int getHeight(TreeNode *node) {
        if(!node) 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 : max(leftHeight, rightHeight) + 1;
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};