算法D15 | 二叉树2 | 102. 层序遍历 226.翻转二叉树 101. 对称二叉树

102. 层序遍历 

看完本篇可以一口气刷十道题，试一试， 层序遍历并不难，大家可以很快刷了十道题。

题目链接/文章讲解/视频讲解：代码随想录

依然，由于访问顺序和操作顺序不同，利用栈和队列来调整输出顺序。

队列先进先出，符合一层一层遍历的逻辑，这也就是图论中的广度优先遍历，BFS。

而之前D14用栈先进后出适合模拟深度优先遍历也就是递归的逻辑， DFS。

python版本：

from collections import deque

class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root: return []

        queue = deque([root])
        result = []
        while queue:
            level = []
            for _ in range(len(queue)):
                cur = queue.popleft()
                level.append(cur.val)
                if cur.left:
                    queue.append(cur.left)
                if cur.right:
                    queue.append(cur.right)
            result.append(level)
        return result    

C++版本：

队列里放的是Treenode的指针，这样才可以在遍历的时候仍然能够记录原来树的关系。用size记录每一层元素的数量。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root!=NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            for (int i=0; i<size; i++) {
                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;
    }
};

有10道题目都是同一个模板的问题，可以练习。

TODO: 102/107/199/637/429/515/116/117/104/111。

226.翻转二叉树 （优先掌握递归） 

这道题目 一些做过的同学 理解的也不够深入，建议大家先看我的视频讲解，无论做过没做过，都会有很大收获。

题目链接/文章讲解/视频讲解：代码随想录

这个题依然可以用前中后序遍历（递归法，利用栈实现迭代法）或者利用队列来实现层次遍历解决。递归法的前序遍历是最直接简单的。

Python递归前序遍历：

class Solution:
    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:
        if not root: return None
        root.left, root.right = root.right, root.left
        self.invertTree(root.left)
        self.invertTree(root.right)
        return root

C++递归前序遍历：

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. 对称二叉树 （优先掌握递归）  

先看视频讲解，会更容易一些。 

题目链接/文章讲解/视频讲解：代码随想录

Python版本：

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return true
        return self.compare(root.left, root.right)

    def compare(self, left, right):
        if left==None and right!=None: return False
        elif left!=None and right==None: return False
        elif left==None and right==None: return True
        elif left.val != right.val: return False

        outside = self.compare(left.left, right.right)
        inside = self.compare(left.right, right.left)
        return outside & inside

C++版本：

如果内层函数只是传入参数不同，打包成一个新的函数似乎也更好一些，简化了内部逻辑。

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

与这个题类似的还有， TODO: 100/572。