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

层序遍历 

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

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

这道题很基础，主要就是通过使用队列来实现层序遍历。值得一提的是，如果队列里面存储的是NULL，队列也是有size的，说明必须要提前判断一下root的值，不能无脑存储进去，然后通过size是否为0来判断root是否为NULL。

vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if(root) que.push(root);
        TreeNode* node=root;        
        while(que.size()){
            vector<int> tmp;   
            int size=que.size();         
            for(int i=0;i<size;i++){
                node=que.front();
                tmp.push_back(node->val);
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(tmp);
        }
        return res;
    }

使用递归方法——

递归直接储存到result数组里面，故而返回值void，每次要传入当前节点指针、数组还有深度（来确定存入result数组的哪个位置）。递归截至的条件是当前指针为NULL，每次递归除了储存当前值到result数组还有递归地调用函数来遍历左右子节点外，还要在每次到达新一层的时候创建一个数组来储存这一层的值。

void order(TreeNode* cur, vector<vector<int>>& result, int depth)
    {
        if (cur == nullptr) return;
        if (result.size() == depth) result.push_back(vector<int>());
        result[depth].push_back(cur->val);
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        int depth = 0;
        order(root, result, depth);
        return result;
    }

文章里面还列出了十道习题来巩固层序遍历，基本上就是在层序遍历的基础上改了改。

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

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

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

这道题其实就是将每一个节点的左右子节点都互换一下就行，其中遍历是必然的。对于递归地遍历方式，前序遍历和后序遍历都可以在原来的基础上修改得到，但是对于中序遍历，如果真的按照左根右的顺序遍历的话，会导致左边的节点被swap了两遍，但是右边的子节点一遍也没有swap，所以不能在原来的基础上直接修改，还得递归的顺序改为左根左。

还有一点，一般递归函数有返回值的话，就需要在本层递归中接住返回的值，但是这个递归函数并没有这样，这是因为递归函数最终返回的东西还是传入参数本身，只是它的左右子节点发生变化，而且传入的是指针，因此不用接住就已经发生变化了，所以无论设不设置root->left=invertTree(root->left)这样的代码结果都不变。

前序遍历——

TreeNode* invertTree(TreeNode* root) {
        if(root==NULL) return root;
        swap(root->right,root->left);
        invertTree(root->left);
        invertTree(root->right);
        return root;
    }

中序遍历——

TreeNode* invertTree(TreeNode* root) {
        if(root==NULL) return root;
        invertTree(root->left);
        swap(root->right,root->left);
        invertTree(root->left);
        return root;
    }

101. 对称二叉树 （优先掌握递归）  

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

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

文章里面的递归方式，强调了使用后序遍历，其实我感觉后序遍历很直白不需要太解释，每次传入两个节点来比较，传入的节点是镜面对称的节点，也就是用左子树的左子树和右子树的右子树比较，左子树的右子树和右子树的左子树比较。符合递归三部曲，首先传入要比较的两个节点，确定返回是bool类型，再确定何时终止递归（考虑能够确定最终情况的条件是什么，何时一定false，何时一定true），然后确定每次递归要做的是什么，就是要判断这两个节点是否满足他们子树满足镜面对称，来确定这两个节点是否镜面对称——

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

文章里面还介绍了迭代法。主要就是每次取出两个节点来比较，然后再按照它们子树的比较顺序来加入队列（即使是空子树也要加入），这样每次连续取出的两个就是恰好位置镜面对称的元素——

bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列
        
        while (!que.empty()) {  // 接下来就要判断这两个树是否相互翻转
            TreeNode* leftNode = que.front(); que.pop();
            TreeNode* rightNode = que.front(); que.pop();
            if (!leftNode && !rightNode) {  // 左节点为空、右节点为空，此时说明是对称的
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }

我用的是层序遍历通过的，很容易理解——

bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> que;
        if(root) que.push(root);
        while(que.size()){
            int size=que.size();
            vector<int> vec;
            for(int i=0;i<size;i++){
                TreeNode* node=que.front();
                que.pop();
                if(node->left) {
                    que.push(node->left);
                    vec.push_back(node->left->val);
                }else vec.push_back(200);
                if(node->right) {
                    que.push(node->right);
                    vec.push_back(node->right->val);
                }else vec.push_back(200);
            }
            for(int i=0;i<size;i++){
                if(vec[i]!=vec[size*2-1-i]) return false;
            }
        }
        return true;
    }