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

● 层序遍历

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()){
            vector<int> vec;
            int size = que.size();
            while(size--){
                TreeNode* cur = que.front();
                vec.push_back(cur->val);
                que.pop();
                if(cur->left){
                    que.push(cur->left);
                }
                if(cur->right){
                    que.push(cur->right);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};

● 226.翻转二叉树 

//  递归法
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;
    }
};

//  前序迭代法
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr) return root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            swap(node->left,node->right);
            if(node->right) st.push(node->right);
            if(node->left) st.push(node->left);
        }
        return root;
    }
};

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

● 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!=nullptr&&right!=nullptr&&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==nullptr) return true;
        return compare(root->left,root->right);
    }
};