代码随想录算法训练营33期 第十四天|层序遍历、226.翻转二叉树 （优先掌握递归）、101. 对称二叉树 （优先掌握递归）

层序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if (root!=nullptr) que.push(root);
        while (!que.empty()){
            int size = que.size(); //保存当前层有多少个元素，防止程序遍历时由于左结点的子节点入队导致的，右节点和左子节点同时存在队伍里导致的层序混乱。
            vector<int> layer;
            while (size--){
                TreeNode* node = que.front();
                que.pop();
                layer.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(layer);
        }
        return result;
    }
};

关键点：两层while，内层while根据每层的size负责处理每层的节点信息。

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

//递归写法
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        while (root == nullptr) return root;
        swap(root->left, root->right);
        if (root->left) invertTree(root->left);
        if (root->right) invertTree(root->right);
        return root;
    }
};

//非递归写法
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        TreeNode* cur;
        if (root != nullptr) st.push(root);
        while (!st.empty()){
            cur = st.top();
            st.pop();
            swap(cur->left, cur->right);
            if (cur->right) st.push(cur->right);
            if (cur->left) st.push(cur->left);
            
        }
        return root;
    }
};

注意点：
swap(cur->left, cur->right);不用担心cur->left或cur->right为空的情况，因为即使是null也能swap。

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

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right){
        if (left==nullptr && right==nullptr) return true;
        else if (left!=nullptr && right==nullptr) return false;
        else if (left==nullptr && right!=nullptr) return false;
        else if (left->val != right->val) return false;

        bool insame = compare(left->left, right->right);
        bool outsame = compare(left->right, right->left);
        return insame&&outsame;
    }
    bool isSymmetric(TreeNode* root) {
    	/
        return compare(root->left, root->right);
    }
};