算法题打卡day15 | 102.层序遍历、226.翻转二叉树、101.对称二叉树

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

状态：Debug后AC。

层序遍历的思路其实现在看来和迭代法做前序遍历很接近。都是利用配接器规范遍历的顺序。不同的是层序遍历是队列。代码如下：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        //用一个队列存储每一层的孩子节点，如果不为空，就迭代下去
        vector<vector<int>> res;
        deque<TreeNode*> que;

        if(root == nullptr) return res;

        que.push_back(root);
        while(!que.empty()){
            vector<int> record;
            int len = que.size();

            for(int i = 0; i < len; ++i){
                TreeNode* node = que.front();
                que.pop_front();
                if(node->left) que.push_back(node->left);
                if(node->right) que.push_back(node->right);
                record.push_back(node->val);
            }
            res.push_back(record);
        }
        return res;
    }
};

学会二叉树的层序遍历，可以一口气打完以下十题：

• 102. 二叉树的层序遍历 - 力扣（LeetCode）
• 107. 二叉树的层序遍历 II - 力扣（LeetCode）
• 199. 二叉树的右视图 - 力扣（LeetCode）
• 637. 二叉树的层平均值 - 力扣（LeetCode）
• 429. N 叉树的层序遍历 - 力扣（LeetCode）
• 515. 在每个树行中找最大值 - 力扣（LeetCode）
• 116. 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）
• 117. 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）
• 104. 二叉树的最大深度 - 力扣（LeetCode）
• 111. 二叉树的最小深度 - 力扣（LeetCode）

上面的题目都是在层序遍历的这个框架下进行的一些变化，稍作思考变化即可。

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

状态：了解思路后递归迭代均AC。

没什么好说的，实际推演一下交换的流程即可。代码如下：

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        //第一想法是递归来做
        // if(root == nullptr) return root;

        // swap(root->left, root->right);
        // invertTree(root->left);
        // invertTree(root->right);

        // return root;

        //尝试用迭代来实现上述过程
        stack<TreeNode*> st;
        
        if(root == nullptr) return root;

        st.push(root);

        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left, node->right);
            if(node->left) st.push(node->left);
            if(node->right) st.push(node->right);
        }
        
        return root;
    }
};

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

状态：无思路。

 递归进行镜像比较，注意递归的终止条件判断较为复杂。

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right){
        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 return compare(left->left, right->right) && compare(left->right, right->left);
    }

    bool isSymmetric(TreeNode* root) {
        if(root == nullptr) return true;

        bool res = compare(root->left, root->right);

        return res;
    }
};