day15● 层序遍历 10 ● 226.翻转二叉树 ● 101.对称二叉树

 层序遍历  10 

102. 二叉树的层序遍历 - 力扣（LeetCode）

层序遍历的意思是一层一层的遍历，用到的数据结构是队列，用来存访问过的元素，另外设置一个size，表示每层的数量，用于限制弹出队列元素的个数

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        int size;
        vector<vector<int>> result;
        que.push(root);
        if (root == NULL)return {  };
        while (!que.empty()) {
            size = que.size();
            vector<int> res;
            while (size--) {
                TreeNode* cur;
                cur = que.front();
                que.pop();
                res.push_back(cur->val);
                if (cur->left)que.push(cur->left);
                if (cur->right)que.push(cur->right);
            }
            result.push_back(res);
        }
        return result;
    }
};

104. 二叉树的最大深度 - 力扣（LeetCode）

求最大深度，在层次遍历的基础上增加一个计数器，遍历完这一层将计数器加一

class Solution {
public:
    int maxDepth(TreeNode* root) {
        if (root == nullptr)return 0;
        //层序遍历 统计一共遍历了几层
        queue<TreeNode*> que;
        que.push(root);
        int size;
        int count = 0;
        while (!que.empty()) {
            size = que.size();
            count++;
            while (size--) {
                TreeNode* cur;
                cur = que.front();
                que.pop();
                if (cur->left)que.push(cur->left);
                if (cur->right)que.push(cur->right);
            }
        }
        return count;
    }
};

226.翻转二叉树 

226. 翻转二叉树 - 力扣（LeetCode）

采用递归的方法，分别使用前序遍历和后续遍历的方式递归的交换左右结点

采用中序遍历也可以，但需要注意中序遍历交换之后原来的右子树变成了现在的左子树因此在下一次递归的时候应该传入当前的左子树

//前序遍历
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr)return nullptr;
        swap(root->left, root->right);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

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

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

 101.对称二叉树

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

本题主要使用后序遍历，遇到需要收集左右孩子信息，返回上一结点的情况，都需要使用后序遍历，判断是不是对称二叉树，其实就是判断根节点的左右子树可不可以相互反转，需要同时遍历两个子树，分别为左右中，右左中的顺序，逐个比较

方法：递归法

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

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

2. 确定终止条件

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

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

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

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

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

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

3. 确定单层递归的逻辑

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

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

class Solution {
public:
    //递归函数
    bool pan(TreeNode* left, TreeNode* right) {
        bool pan1, pan2;
        //确定终止条件
        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;
        //此时剩下左孩子等于右孩子 开始循环
        else {
            pan1=pan(left->left, right->right);
            pan2=pan(left->right, right->left);
        }
        return pan1 && pan2;
    }
    bool isSymmetric(TreeNode* root) {
        if (root->left != nullptr && root->right != nullptr) {
            return pan(root->left, root->right);
        }
        //只有根节点
        else if (root->left == nullptr && root->right == nullptr)return true;
        else return false;
    }
};