算法day15 二叉树part02

层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {

    vector<vector<int>> res;
    if(root==nullptr){
        return res;
    }
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty()){
        vector<int> level;
        int levelSize=q.size();
        while(levelSize>0){
            TreeNode* cur=q.front();
            q.pop();
            level.push_back(cur->val);
            if(cur->left) q.push(cur->left);
            if(cur->right) q.push(cur->right);
            levelSize--;
        }
        res.push_back(level);
       
    }

    return res;
    }
};

 模板代码，可以拓展到很多题目，其中用levelsize记录当前层节点数很巧。

 226.翻转二叉树

迭代法

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr){
            return root;
        }

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

        return root;
    }
};

以前序遍历为基础，每次访问到一个节点时直接交换当前节点的左右孩子。

递归

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr){
            return root;
        }

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


    }
};

 101. 对称二叉树

迭代法

class Solution {
public:
    bool compare(TreeNode* u,TreeNode* v){
        queue<TreeNode*> q;
        q.emplace(u);
        q.emplace(v);
        while(!q.empty()){
            TreeNode* cur1=q.front();q.pop();
            TreeNode* cur2=q.front();q.pop();
            if(cur1==nullptr && cur2==nullptr){
                continue;
            }
            else if((cur1==nullptr && cur2!=nullptr)||(cur1!=nullptr && cur2==nullptr)||(cur1->val!=cur2->val)){
                return false;
            }
            q.emplace(cur1->left);
            q.emplace(cur2->right);

            q.emplace(cur1->right);
            q.emplace(cur2->left);
        }
        return true;
    }
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr){
            return true;
        }
        return compare(root->left,root->right);


       
    }
};

利用了一个队列，每次比较左右两个对称节点的val是否相等  然后再依次将这两个节点的左孩子 右孩子， 右孩子、左孩子入队。

递归

class Solution {
public:
    bool compare(TreeNode* p,TreeNode* q){
        if(p==nullptr && q==nullptr){
            return true;
        }
        else if((p==nullptr && q!=nullptr) || (p!=nullptr && q==nullptr)){
            return false;
        }

        return p->val==q->val && compare(p->left,q->right) && compare(p->right,q->left);

       
    }
    bool isSymmetric(TreeNode* root) {
        if(root==nullptr){
            return true;
        }
        return compare(root->left,root->right);


       
    }
};

 递归判断每个节点的左右子树是否对称