力扣刷题(day0031)对称二叉树

最新推荐文章于 2024-05-15 18:29:40 发布

「已注销」

最新推荐文章于 2024-05-15 18:29:40 发布

阅读量1.7k

点赞数

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/weixin_51600314/article/details/123759525

版权

给你一个二叉树的根节点 root ，检查它是否轴对称。

示例 1：

 输入：root = [1,2,2,3,4,4,3]
 输出：true

示例 2：

 输入：root = [1,2,2,null,3,null,3]
 输出：false

提示：

树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？

递归法：

/**
 * 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:
    bool compare(TreeNode* left,TreeNode* right){
        //排除空节点情况
        if(left!=NULL && right==NULL)return false;
        else if(left==NULL && right!=NULL)return false;
        else if(left==NULL && right==NULL)return true;
        //排除内容是否一致
        else if(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==NULL)return true;
        return compare(root->left,root->right);
    }
};

递归遍历化简版：

/**
 * 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:
    bool compare(TreeNode* left,TreeNode* right){
        if(left!=NULL&&right==NULL)return false;
        else if(left==NULL&&right!=NULL)return false;
        else if(left==NULL&&right==NULL)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==NULL)return true;
        return compare(root->left,root->right);
    }
};

使用队列：

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)return true;
        queue<TreeNode*>que;
        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->val!=rightNode->val))return false;
            que.push(leftNode->left);
            que.push(rightNode->right);
            que.push(leftNode->right);
            que.push(rightNode->left);
        }
        return true;
    }
};

使用栈：

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)return true;
        stack<TreeNode*>st;
        st.push(root->left);
        st.push(root->right);
        while(!st.empty()){
            TreeNode* leftNode=st.top();st.pop();
            TreeNode* rightNode=st.top();st.pop();
            if(!leftNode&&!rightNode)continue;
            if(!leftNode||!rightNode||(leftNode->val!=rightNode->val))return false;
            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;
    }
};