Day15 | 102. 二叉树的层序遍历、226.翻转二叉树、101.对称二叉树

102.二叉树的层序遍历

二叉树的层序遍历由于需要一层一层的遍历，所以需要使先进入的元素先出来，即用队列的数据结构，值得注意的是需要每层入队后记录队列中的元素（即本层的元素），这样才能够每次只出队一层的元素

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        if(root== nullptr)return res;
        queue<TreeNode*> s;
        TreeNode*p=root;
        s.push(p);
        while (!s.empty()){
            int size=s.size();//记录一层有多少个结点
            vector<int> v;
            while (size--){
                p=s.front();
                s.pop();
                v.push_back(p->val);
                if(p->left)
                    s.push(p->left);
                if(p->right)
                    s.push(p->right);
            }
            res.push_back(v);
        }
        return res;
    }
};

226.翻转二叉树

我的思路是用层序遍历来翻转，在出队结点的左右孩子入队前，先将不全为空的左右孩子互换位置，再将互换位置后的左右孩子入队

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> q;
        if(root== nullptr)return root;
        TreeNode*p=root;
        q.push(root);
        while (!q.empty()){
            int size=q.size();
            TreeNode*tmp= nullptr;
            while (size--){//层序遍历的模板
                p=q.front();
                q.pop();
                if(p->left||p->right){
                //左右孩子都为空互换之后不变
                    tmp=p->left;
                    p->left=p->right;
                    p->right=tmp;
                }
                //先互换再入队
                if(p->left)
                    q.push(p->left);
                if(p->right)
                    q.push(p->right);
            }
        }
        return root;
    }
};

101.对称二叉树

刚开始的思路是用左右子树的中序遍历来判断是否对称
这里左子树的中序遍历为324，右子树为423，左子树从前向后遍历的每个元素正好与右子树从后向前的每个元素相等

但是当遇到这种情况时，由于两边子树的中序遍历都是22，所以无法判断是否是对称的

所以换了基于后序遍历的实现思路，我们需要对比外侧和内侧的节点是否分别相同，若相同则继续比较

• 确定递归函数参数和返回值：bool compare(TreeNode*left,TreeNode*right)
• 确定终止条件：

if(left== nullptr&&right!= nullptr)return 0;
else if(left!= nullptr&&right== nullptr)return 0;
else if(left== nullptr&&right== nullptr)return 1;
else if(left->val!=right->val)return 0;

• 确定单层递归逻辑

 int outside=compare(left->left,right->right);
 int inside=compare(left->right,right->left);
 int res=outside&&inside;
 return res;

函数实现如下：

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