YOLO 普通 2024年3月21日下午2:22

/*请实现一个函数，用来判断一棵二叉树是不是对称的。
 如果一棵二叉树和它的镜像一样，那么它是对称的。 */
class Solution {
    public boolean checkSymmetricTree(TreeNode root) {
        if(root == null || root.left == null && root.right == null)  
            return true;
        return judgetree(root.left , root.right);

    }
    public boolean judgetree(TreeNode rootA ,TreeNode rootB){
        if(rootA == null && rootB == null){
            return true;
        }
        if(rootA == null || rootB == null)
            return false;
        if(rootA.val != rootB.val)
            return false;

        return judgetree(rootA.left,rootB.right)&&judgetree(rootA.right,rootB.left);
    }

}

0 赞同 0 条回复

kfaebot 普通 2024年3月14日上午10:18

/**
 * 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:
    //步骤1：定义返回值和参数
    bool compare_tree(TreeNode* left,TreeNode* right){
        //步骤2：定义终止条件
        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;
        }

        //步骤3：定义遍历过程
        bool out=compare_tree(left->left,right->right); //左子树：左；右子树：右
        bool in=compare_tree(left->right,right->left); //左子树：右；右子树：左
        if(out&&in){
            return true;
        }
        else{
            return false;
        }

    }
    bool checkSymmetricTree(TreeNode* root) {
        if(root==nullptr){//根节点为空
            return true;
        }
        return compare_tree(root->left,root->right);
    }
};

0 赞同 0 条回复

HU 普通 2024年3月14日上午10:10

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var checkSymmetricTree = function(root) {
    // 如果root为空或者root仅一个节点，则返回真
    if(root == null || (root.left == null && root.right == null)) return true;

    // 否则返回判断root.left和root.right是否互为镜像二叉树
    return judgeMirror(root.left, root.right);
};

// 判断rootA和rootB是否互为镜像二叉树
const judgeMirror = (rootA, rootB) => {
    // 如果rootA和rootB都为空，则返回真
    if(rootA == null && rootB == null) return true;

    // 如果rootA和rootB都不为空
    if(rootA != null && rootB != null) {
        // 如果rootA的值等于rootB的值，并且rootA.left和rootB.right互为镜像二叉树，并且rootA.right和rootB.left互为镜像二叉树
        // 则返回真
        if(rootA.val == rootB.val && judgeMirror(rootA.left, rootB.right) && judgeMirror(rootA.right, rootB.left)) {
            return true;
        } 
    }

    // 其他情况返回假
    return false;
}

0 赞同 0 条回复

RunAsOne 普通 2024年3月12日下午1:51

第n次打卡

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def check(self, L, R):
        if not L and not R:
            return True
        if not L or not R or L.val != R.val:
            return False
        return self.check(L.left, R.right) and self.check(L.right, R.left)



    def checkSymmetricTree(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: bool
        """
        if not root or (not root.left and not root.right):
            return True

        return self.check(root.left, root.right)

0 赞同 0 条回复

Let it be 永久会员 2024年3月11日下午9:43

class Solution {
public boolean checkSymmetricTree(TreeNode root) {
return root null || recur(root.left, root .right);
}
public boolean recur(TreeNode L, TreeNode R){
if(L null && R null)return true;
if(L null || R null || L.val != R.val) return false;
return recur(L.left, R.right) && recur(L.right, R.left);
}
}时间空间复杂度O（n）

0 赞同 0 条回复

MARS 普通 2024年3月11日下午8:59

day7第二题

function checkSymmetricTree(root: TreeNode | null): boolean {
    if (root == null) return true
    let queue = []
    queue.push(root.left)
    queue.push(root.right)
    while (queue.length > 0) {
        let left = queue.shift()!
        let right = queue.shift()!
        if (left == null && right != null) return false   //判断
        else if (left != null && right == null) return false
        else if (left?.val != right?.val) return false
        else if (left == null && right == null) continue  //都为空 继续
        queue.push(left.left)
        queue.push(right.right)
        queue.push(left.right)
        queue.push(right.left)
    }
    return true  //一直continue就是成功
}

0 赞同 0 条回复

=.= 普通 2024年3月9日下午11:10

/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean checkSymmetricTree(TreeNode root) {
if(root null) return true;

    return checkSubTree(root.left, root.right);
}

public boolean checkSubTree(TreeNode left, TreeNode right){
    if(left == null && right == null) return true;
    if(left == null || right == null) return false;
    if(left.val != right.val) return false;

    return checkSubTree(left.left, right.right) && checkSubTree(left.right, right.left);
}

}

时空复杂度O(n)

0 赞同 0 条回复

mpweixin用户普通 2024年3月9日下午10:28

java
class Solution{
public boolean checkSymmetricTree(TreeNode root){
return check(root, root);
}

public boolean check(TreeNode p, TreeNode q){
    if(p == null && q == null){
        return true;
    }
    if(p == null || q == null){
        return false;
    }
    return p.val == q.val && check(p.left, q.right) && check(p.right, q.left);
}

}
提交

0 赞同 0 条回复

神经蛙普通 2024年3月9日下午10:25

class Solution {
public:

bool checkSymmetric(TreeNode *left, TreeNode *right)
{
    if(!left && !right) return true;

    if((!left && right )|| ( left && !right) )
     {
         return false;
     }
     return left->val == right->val &&checkSymmetric(left->left, right->right) && checkSymmetric(left->right, right->left);
}

bool checkSymmetricTree(TreeNode* root) {
     return checkSymmetric(root, root);
}

};
打卡

0 赞同 0 条回复

零普通 2024年3月9日下午9:58

代码;


class Solution {
    public boolean checkSymmetricTree(TreeNode root) {
        return judgeSame(root,root);
    }

    public boolean judgeSame(TreeNode t1, TreeNode t2) {
        if (null == t1 && null == t2) {
            return true;
        }
        if (null == t1 || null == t2) {
            return false;
        }
        return t1.val == t2.val && judgeSame(t1.left,t2.right) && judgeSame(t1.right,t2.left);
    }
}

0 赞同 0 条回复

莫～慢～待普通 2024年3月9日下午3:10

class Solution {
public boolean checkSymmetricTree(TreeNode root) {
if((rootnull)||((root.leftnull)&&(root.rightnull)))
return true;
return check(root.left,root.right);
}
public boolean check(TreeNode left,TreeNode right)
{
if(leftnull&&rightnull)
return true;
if(leftnull||rightnull)
return false;
if(left.val!=right.val)
return false;
return check(left.left,right.right)&&check(left.right,right.left);
}
}
递归判断下去，左子树的左子树和右子树的右子树是否相同，左子树的右子树和右子树的左子树是否相同

0 赞同 0 条回复

方铎码农普通 2024年3月9日下午12:55

class Solution {
    public boolean checkSymmetricTree(TreeNode root) {
        if(root == null || (root.left == null && root.right == null)){
            return true;
        }

        return check(root.left,root.right);
    }

    private boolean check(TreeNode left, TreeNode right){
        if(left == null && right == null) return true;
        if(left == null || right == null) return false;
        if(left.val != right.val) return false; // 一处不对称立刻返回false结束，而此处对称就继续递归至结尾
        return check(left.left,right.right)&&check(left.right,right.left);
    }
}

时间空间复杂度均为$O(n)$

0 赞同 0 条回复

　南木普通 2024年3月8日下午10:47

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean checkSymmetricTree(TreeNode root) {
        if(root == null || (root.left == null && root.right == null)){
            return true;
        }

        return f(root.left, root.right);
    }
    // 判断B是不是以A阶段为根节点的子树
    public boolean f(TreeNode A, TreeNode B){
        if(A == null && B == null){
            return true;
        }

        if(A == null || B == null){
            return false;
        }

        if(A.val != B.val){
            return false;
        }

        return f(A.left, B.right) && f(A.right, B.left);
    }
}

0 赞同 0 条回复

Jimmy 普通 2024年3月8日下午8:21

时间复杂度，空间复杂度都为O(n)

/**
 * 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 != nullptr && right == nullptr)return false;
        else if(left == nullptr && right != nullptr)return false;
        else if(left == nullptr && right == nullptr)return true;
        else if(left->val != right->val)return false;

        bool outside = compare(left->left,right->right);
        bool inside = compare(left->right,right->left);
        return outside && inside;
    }

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

0 赞同 0 条回复

叫不醒装睡的人普通 2024年3月8日下午6:30

class Solution {
    // 检查左右子树的元素是否对称相等
    // 逐层对称位置的元素进行比较
    public boolean checkSymmetricTree(TreeNode root) {
        if (root == null || root.left == null && root.right == null) {
            return true;
        }
        return check(root.left, root.right);
    }

    private boolean check(TreeNode leftTree, TreeNode rightTree) {
        if (leftTree == null && rightTree == null) {
            return true;
        }
        if ((leftTree == null && rightTree != null) || (leftTree != null && rightTree == null)) {
            return false;
        }
        if (leftTree.val != rightTree.val) {
            return false;
        }
        return check(leftTree.right, rightTree.left) && check(leftTree.left, rightTree.right);
    }
    // 时间复杂度为 O(n)
    // 每次调用 check 方法时检查左右两边对称位置的元素，最多 n/2 次
    // 空间复杂度为 O(n)
    // 当二叉树退化成链表时，空间占用情况最差
}

0 赞同 0 条回复

白雪公主倒拔垂杨柳永久会员 2024年3月8日下午5:19

class Solution {
    public boolean checkSymmetricTree(TreeNode root) {
        if(root==null || root.left==null && root.right==null){
            return true;
        }

        return f(root.left,root.right);
    }

    public boolean f(TreeNode A,TreeNode B){
        if(A==null && B==null){
            return true;
        }
        if(A==null || B==null){
            return false;
        }
        if(A.val!=B.val){
            return false;
        }

        return f(A.left,B.right)&&f(A.right,B.left);
    }
}

时间复杂度：O(n)
空间复杂度：树的高度

0 赞同 0 条回复

NULL 普通 2024年3月8日下午4:46

class Solution {
public boolean checkSymmetricTree(TreeNode root) {
return check(root, root);
}
public boolean check(TreeNode left, TreeNode right){
if(left null && right null)return true;
if(left null || right null)return false;
return left.val right.val & check(left.left, right.right) & check(left.right, right.left);// 递归判断
}
}

0 赞同 0 条回复

一个达不刘普通 2024年3月8日下午4:05

class Solution {
public:
bool checkSymmetricTree(TreeNode* root) {
if(root nullptr||root->left nullptr &&root->right nullptr) return true;

    return f(root->left, root->right);
}

bool f(TreeNode* A, TreeNode*B){//判断A和B是否对称
    if(A==nullptr && B == nullptr ) return true;
    if(A==nullptr || B == nullptr ) return false;
    if(A->val != B->val) return false;

    return f(A->left, B->right) && f(A->right, B->left);
}

};

0 赞同 0 条回复

南梁陈庆之普通 2024年3月8日下午3:32

广度遍历，判断每一层数据是否轴对称
时间复杂度O（N），空间复杂度O（N）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean checkSymmetricTree(TreeNode root) {
        if (root == null) {
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            int n = queue.size();
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                TreeNode node = queue.poll();
                if (node != null) {
                    arr[i] = node.val;
                    queue.add(node.left);
                    queue.add(node.right);
                } else {
                    arr[i] = -1;
                }

            }
            for (int i = 0; i < n / 2; i++) {
                if (arr[i] != arr[n - 1 - i]) {
                    return false;
                }
            }


        }
        return true;
    }
}

0 赞同 0 条回复

mpweixin用户普通 2024年3月8日上午11:26

class Solution {
public boolean checkSymmetricTree(TreeNode root) {
return root null || recur(root.left, root.right);
}
boolean recur(TreeNode L, TreeNode R) {
if(L null && R null) return true;
if(L null || R null || L.val != R.val) return false;
return recur(L.left, R.right) && recur(L.right, R.left);
}
}

思路：
checkSymmetricTree(root) ：
若根节点 root 为空，则直接返回 true 。
返回值：即 recur(root.left, root.right) ;
recur(L, R) ：

终止条件：
当 L 和 R 同时越过叶节点：此树从顶至底的节点都对称，因此返回 true ；
当 L 或 R 中只有一个越过叶节点：此树不对称，因此返回 false；
当节点 L 值 ≠= 节点 R 值：此树不对称，因此返回 false ；
递推工作：
判断两节点 L.left 和 R.right 是否对称，即 recur(L.left, R.right) ；
判断两节点 L.right 和 R.left 是否对称，即 recur(L.right, R.left) ；
返回值：两对节点都对称时，才是对称树，因此用与逻辑符 && 连接。

0 赞同 0 条回复

Free 普通 2024年3月8日上午11:22

/**
 * 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 checkSymmetricTree(TreeNode* root) 
    {
        if(root == nullptr)
            return true;
        return checkSymmetricTree(root->left, root->right);
    }

    bool checkSymmetricTree(TreeNode* left, TreeNode* right)
    {
        if(left == nullptr && right == nullptr)
            return true;
        if(left == nullptr || right == nullptr)
            return false;
        if(left->val != right->val)
            return false;
        return checkSymmetricTree(left->left, right->right) && checkSymmetricTree(left->right, right->left);
    }
};

时空复杂度O(n)

0 赞同 0 条回复

Thaddeus 永久会员 2024年3月8日上午10:12

打卡

class Solution {
public:
    bool recur(TreeNode* root1, TreeNode* root2) {
        if(!root1 && !root2) return true;
        if(!root1 || !root2) return false;
        if(root1->val != root2->val) return false;
        return recur(root1->left, root2->right) && recur(root1->right, root2->left);
    }
    bool checkSymmetricTree(TreeNode* root) {
        if(!root) return true;
        return recur(root->left, root->right);
    }
};

0 赞同 0 条回复

Yuki 永久会员 2024年3月8日上午9:36

打卡
https://leetcode.cn/problems/dui-cheng-de-er-cha-shu-lcof/solutions/2674257/dui-cheng-er-cha-shu-by-yukislab-vh88

0 赞同 0 条回复

Yox 普通 2024年3月8日上午5:37

Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

class Solution:
def checkSymmetricTree(self, root: Optional[TreeNode]) -> bool:
if not root:
return True
def recur(L,R):
if not L and not R:return True
if not L or not R or L.val != R.val:
return False
return recur(L.right,R.left) and recur(L.left,R.right)

    return recur(root.left,root.right)

时间空间 o n

0 赞同 0 条回复

Raphtalia. 普通 2024年3月8日上午12:57

/**
* 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 checkSymmetricTree(TreeNode root) {
if(!root) return true;
return recur(root->left,root->right);
}
bool recur(TreeNode* left, TreeNode* right){
if(left nullptr && right nullptr) return true;
if(left nullptr || right nullptr || left->val != right->val) return false;
return recur(left->left, right->right) && recur(left->right, right->left);
}
};
时间复杂度O(n)，空间复杂度O(logn)

0 赞同 0 条回复

heathhou 普通 2024年3月7日下午11:13

class Solution {
public:

    bool checkSymmetricTree(TreeNode* root) {

        if(root == nullptr || (root->left == nullptr && root->right == nullptr)){
            return true;
        }
        return f(root->left, root->right);

    }
    // 递归函数：判断二叉树是否相同
    bool f(TreeNode* root1, TreeNode* root2){
        // 递归函数的结束条件
        if(root1 == nullptr && root2 == nullptr){
            return true;
        }else if(root1 == nullptr || root2 == nullptr){
            return false;
        }else if(root1->val != root2->val){
            return false;
        }

        // 递归函数的等价关系式
        return f(root1->left, root2->right) && f(root1->right, root2->left);
    }
};

0 赞同 0 条回复

机电皮怪永久会员 2024年3月7日下午10:16

时间复杂度O(n)
空间复杂度O(n)

“`C++
class Solution {
public:
bool checkSymmetricTree(TreeNode* root) {
return check(root, root);
}

bool check(TreeNode* left, TreeNode* right)
{
    if(left == nullptr && right == nullptr)
    {
        return true;
    }
    else if(left == nullptr || right == nullptr)
    {
        return false;
    }

    return (left->val == right->val) && check(left->left, right->right) && check(left->right, right->left);
}

};

“`

0 赞同 0 条回复

紫芝普通 2024年3月7日下午9:01

思路：递归版本，定义一个函数递归处理，根据二叉树对称的图来看，对于两个对称的节点node1（左）和node2（右），判断其子节点是否对称时，只需要递归的判断node1->left and node2->right, node1->right and node2->left。

“`c++
class Solution {
public:
bool checkSymmetricNode(TreeNode* left, TreeNode* right) {
if (left && right) {
if (left->val != right->val) return false;
return checkSymmetricNode(left->left, right->right) && checkSymmetricNode(left->right, right->left);
}
else if (left || right) {
return false;
} else {
return true;
}
}
bool checkSymmetricTree(TreeNode* root) {
if (root == nullptr) return true;
return checkSymmetricNode(root->left, root->right);
}
};
“`

0 赞同 0 条回复

言之命至普通 2024年3月7日下午8:54

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null || (root.left == null && root.right == null)){
            return true;
        }

        return f(root.left, root.right);
    }
    // 判断A B是否是对称的
    public boolean f(TreeNode A, TreeNode B){
        if(A == null && B == null){
            return true;
        }

        if(A == null || B == null){  // A、B其中一个是Null
            return false;
        }

        if(A.val != B.val){// A、B值不相等
            return false;
        }

        return f(A.left, B.right) && f(A.right, B.left);// 递归判断A.left与 B.right是不是对称的，A.right与 B.left是不是对称的
    }
}

时间复杂度：O(n)
空间复杂度：树的高度

0 赞同 0 条回复

王位詮釋普通 2024年3月7日下午8:20

···java
class Solution {
public boolean checkSymmetricTree(TreeNode root) {
return check(root,root);
}
public boolean check(TreeNode left,TreeNode right){
if(leftnull&&rightnull){
return true;
}
if(leftnull||rightnull){
return false;
}
return left.valright.val&&check(left.left,right.right)&&check(left.right,right.left);
}
}
时间复杂度：O(n)，空间复杂度与递归深度有关：O(n)
···

0 赞同 0 条回复

云无深雁影普通 2024年3月7日下午7:14

class Solution {
private boolean isSymmetric(TreeNode leftNode, TreeNode rightNode){
if(leftNode null & rightNodenull)
return true;
if(leftNode null || rightNode null || leftNode.val != rightNode.val)
return false;
return isSymmetric(leftNode.left,rightNode.right) && isSymmetric(leftNode.right,rightNode.left);
}
public boolean checkSymmetricTree(TreeNode root) {
if(root null)
return true;
return isSymmetric(root.left,root.right);

}
//递归实现，时空复杂度均为On

0 赞同 0 条回复

【二叉树专题】剑指 Offer 28. 对称的二叉树

共以下 31 个回答

Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

# 回答此问题取消回复

【二叉树专题】剑指 Offer 28. 对称的二叉树

共以下 31 个回答

Definition for a binary tree node.

class TreeNode:

def init(self, val=0, left=None, right=None):

self.val = val

self.left = left

self.right = right

# 回答此问题 取消回复

# 回答此问题取消回复