代码随想录算法训练营第十五天|二叉树层序遍历10 226.翻转二叉树 101.对称二叉树 2

二叉树层序遍历

题目链接 lc102
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

思路：利用广度优先搜索

1. 首先构建一个二叉树队列，记录每一层出现的元素
2. 在循环中加入每一层的数量，用以判断弹出数量，因为在后续遍历中，可能队列中有当前层元素和下一层元素。

队列先进先出，符合一层一层遍历的逻辑，而用栈先进后出适合模拟深度优先遍历也就是递归的逻辑。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;  // 创建一个二叉树队列
        if (root != nullptr) {
            que.push(root);  // 当头节点不为空，加入到节点队列中
        }
        vector<vector<int>> result;  // 创建二维数组返回值
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left); //左孩子不为空，加入队列
                if (node->right) que.push(node->right); // 有孩子不为空，加入队列
            }
            result.push_back(vec);
        }
        return result;
    }

总结：难度不大，主要是队列的一个模拟过程，并且巧妙的用size来帮助记录遍历。

• 102.二叉树的层序遍历 （✔）
• 107.二叉树的层次遍历II （✔）
  广度优先搜索后，对结果进行翻转
• 199.二叉树的右视图 （✔）
  广度优先搜索后去vector的最后一个元素
• 637.二叉树的层平均值 （✔）
  利用了for循环可以保留size信息，节约内存开销。
  平常做法可以先记录数组信息，然后对数组用迭代器求和除数组长度
• 429.N叉树的层序遍历 （✔）
  用for循环遍历子树，这是N叉树判断是否存在孩子节点的方法

for (Node* child: node->children) {
     que.push(child);
}

• 515.在每个树行中找最大值（✔）

 int max = INT32_MIN;  用来做最小值

• 116.填充每个节点的下一个右侧节点指针 （x）
  连接这一点没有完全拿捏。

 // 连接
                if (i < size - 1) {
                    node->next = que.front();
                }

• 117.填充每个节点的下一个右侧节点指针II (未完成)
• 104.二叉树的最大深度 (✔)
• 111.二叉树的最小深度 (x)

226.翻转二叉树

（二叉树解题的大忌就是自己稀里糊涂的过了（因为这道题相对简单），但是也不知道自己是怎么遍历的。）
题目链接
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

思路1：广度优先搜索，层序遍历

1. 遍历到本层节点的时候，交换左右节点，然后继续遍历

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*>que;
        if (root != nullptr) {
            que.push(root);
        }
        vector<TreeNode*> vec;
        while (!que.empty()) {
            int size = que.size();
            
            while (size--) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right);
                if (node->right) que.push(node->right);
                if (node->left) que.push(node->left);
            }
        }
        return root;
    }
};

总结：因为在做第一题的时候做的比较多的层序遍历，立马就想到了这个方法。相对不难，希望后面再做的时候能够再想到这道题

思路2： （递归）
递归法：

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

参数就是要传入节点的指针，不需要其他参数了，通常此时定下来主要参数，如果在写递归的逻辑中发现还需要其他参数的时候，随时补充。返回值的话其实也不需要，但是题目中给出的要返回root节点的指针，可以直接使用题目定义好的函数，所以就函数的返回类型为TreeNode*。

TreeNode* invertTree(TreeNode* root)

2. 确定终止条件

当前节点为空的时候，就返回

if (root == NULL) return root;

3. 确定单层递归的逻辑

因为是先前序遍历，所以先进行交换左右孩子节点，然后反转左子树，反转右子树。

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

总结：每种方法都应该想到，这样能帮助在解题的时候想到

101.对称二叉树 2

题目链接

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

思路1（递归）

要判断是否对称，那么主要看是否对应节点的左右子节点相等，但是在层数高了以后，还需要分成内外两侧分开判断。用递归三要素进行解题。

1. 确定函数返回值和函数参数

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

返回值自然是bool类型。
bool compare(TreeNode* left, TreeNode* right) {
	
}

2. 确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！

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

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

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

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，而是else if， 
因为我们把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。

3. 函数当前层逻辑

就是处理 左右节点都不为空，且数值相同的情况。
比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
比较内测是否对称，传入左节点的右孩子，右节点的左孩子。
如果左右都对称就返回true ，有一侧不对称就返回false 。

bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
bool isSame = outside && inside;                    // 左子树：中、 右子树：中（逻辑处理）
return isSame;

如上代码中，我们可以看出使用的遍历方式，左子树左右中，右子树右左中，所以我把这个遍历顺序也称之为“后序遍历”（尽管不是严格的后序遍历）。

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

总结：
难度不大，但是也不能轻视做题过程，还需要多做本题！