Симметричное дерево

/**
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left;
 *     public TreeNode right;
 *     public TreeNode(int val, TreeNode left=null, TreeNode right=null) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

public class Solution
{
    private static bool IsSymmetricSubtrees(TreeNode leftNode, TreeNode rightNode)
    {
        if (leftNode == null || rightNode == null)
        {
            return leftNode == null && rightNode == null;
        }
        if (leftNode.val != rightNode.val)
        {
            return false;
        }
        return IsSymmetricSubtrees(leftNode.left, rightNode.right) &&
               IsSymmetricSubtrees(leftNode.right, rightNode.left);
    }

    public static bool IsSymmetric(TreeNode root)
    {
        return IsSymmetricSubtrees(root.left, root.right);
    }
}

#include <vector>

using namespace std;

/**
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */

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

bool isSymmetric(TreeNode* root) {
    return isSymmetricSubtrees(root->left, root->right);
}

package main

/**
 * type TreeNode struct {
 *     Val   int
 *     Left  *TreeNode
 *     Right *TreeNode
 * }
 */

func isSymmetricSubtrees(leftNode *TreeNode, rightNode *TreeNode) bool {
    if leftNode == nil || rightNode == nil {
        return leftNode == nil && rightNode == nil
    }
    if leftNode.Val != rightNode.Val {
        return false
    }
    return isSymmetricSubtrees(leftNode.Left, rightNode.Right) &&
           isSymmetricSubtrees(leftNode.Right, rightNode.Left)
}

func isSymmetric(root *TreeNode) bool {
    return isSymmetricSubtrees(root.Left, root.Right)
}

import java.util.*;

/**
 * class TreeNode {
 *     Integer val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(Integer val) { this.val = val; }
 *     TreeNode(Integer val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

class Solution {
    public boolean isSymmetricSubtrees(TreeNode p, TreeNode q) {
        if (p == null || q == null) {
            return p == null && q == null;
        }
        if (!p.val.equals(q.val)) {
            return false;
        }
        return isSymmetricSubtrees(p.left, q.right) &&
               isSymmetricSubtrees(p.right, q.left);
    }

    public boolean isSymmetric(TreeNode root) {
        return isSymmetricSubtrees(root.left, root.right);
    }
}

from tree_node import TreeNode

# class TreeNode:
#     def __init__(self, val, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right

def is_symmetric_sub_trees(l: Optional[TreeNode], r: Optional[TreeNode]) -> bool:
    if l is None or r is None:
        return l is None and r is None
    if l.val != r.val:
        return False
    return (is_symmetric_sub_trees(l.left, r.right) and
            is_symmetric_sub_trees(l.right, r.left))

def is_symmetric(root: Optional[TreeNode]) -> bool:
    return is_symmetric_sub_trees(root.left, root.right)

import { TreeNode } from './treeNode.js';

/**
 * class TreeNode {
 *     constructor(val, left, right) {
 *         this.val = val;
 *         this.left = (left === undefined ? null : left);
 *         this.right = (right === undefined ? null : right);
 *     }
 * }
 */

export function isSymmetricSubtrees(leftNode, rightNode) {
    if (leftNode === null || rightNode === null) {
        return leftNode === null && rightNode === null;
    }
    if (leftNode.val !== rightNode.val) {
        return false;
    }
    return isSymmetricSubtrees(leftNode.left, rightNode.right) &&
           isSymmetricSubtrees(leftNode.right, rightNode.left);
}

/**
 * @param {TreeNode} root
 * @returns {boolean}
 */
export function isSymmetric(root) {
    return isSymmetricSubtrees(root.left, root.right);
}