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

文档讲解
层序遍历 递归遍历 BFS DFS

102. 二叉树的层序遍历

思路:层序遍历的关键在于把每一层的节点存入一个队列中,并且此时这个代码是从左到右遍历的(注意遍历顺序)

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        queue<TreeNode*> que;
        if(root!=nullptr) que.push(root);
        while(!que.empty())
        {
            int size=que.size();
            vector<int> vec;
            while(size--)
            {
                TreeNode* node=que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left)que.push(node->left);
                if(node->right)que.push(node->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);
        if(root->left)invertTree(root->left);
        if(root->right)invertTree(root->right);
        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;
    }
};

思路:为什么使用统一的中序迭代法是可以用于本题的呢?因为是从叶子节点自顶向上回溯,我们使用中序遍历的问题在于,因为我们是访问过一个子节点,再访问其父亲节点,若这样的话在父亲节点的时候将两个子节点的位置进行交换,第二次访问另外一个子节点的时候,又会访问到上一个子节点,故报错!

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                st.push(node);                          // 中
                st.push(NULL);
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();
                node = st.top();
                st.pop();
                swap(node->left, node->right);          // 节点处理逻辑
            }
        }
        return root;
    }
};

101.对称二叉树

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*>que;
        if(root==nullptr)return true;
        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;
            }
            if((!LeftNode&&RightNode)||(LeftNode&&!RightNode)||(LeftNode->val!=RightNode->val))
            {
                return false;
            }
            que.push(LeftNode->left);
            que.push(RightNode->right);
            que.push(RightNode->left);
            que.push(LeftNode->right);
            
        }
        return true;
    }
};

递归法:

class Solution {
public:
    bool issameTree(TreeNode* p,TreeNode* q)
    {
        if(p==nullptr||q==nullptr)
        {
            return p==q;
        }
        return p->val==q->val&&issameTree(p->left,q->right)&&issameTree(p->right,q->left);
    }
    bool isSymmetric(TreeNode* root) {
        return issameTree(root->left,root->right);
    }
};
  • 6
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值