1 2 2 3 4 4 3

true

1 2 2 null 3 null 3

false

from typing import Optional, List

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

class Solution:
    def isSymmetric(self, root: Optional[TreeNode]) -> bool:
        if not root:
            return True
        
        # 辅助函数：判断两个子树是否镜像对称
        def isMirror(left: Optional[TreeNode], right: Optional[TreeNode]) -> bool:
            if not left and not right:
                return True
            if not left or not right:
                return False
            return (left.val == right.val and 
                    isMirror(left.left, right.right) and 
                    isMirror(left.right, right.left))
        
        return isMirror(root.left, root.right)

# 辅助函数：列表转二叉树
def buildTree(nodes: List[Optional[int]]) -> Optional[TreeNode]:
    if not nodes or nodes[0] == 'null' or nodes[0] is None:
        return None
    
    # 将首元素作为根节点
    root = TreeNode(int(nodes[0]))
    queue = [root]
    idx = 1  # 从第二个元素开始
    
    while queue and idx < len(nodes):
        current = queue.pop(0)
        
        # 构建左子节点
        if idx < len(nodes) and nodes[idx] != 'null' and nodes[idx] is not None:
            current.left = TreeNode(int(nodes[idx]))
            queue.append(current.left)
        idx += 1
        
        # 构建右子节点
        if idx < len(nodes) and nodes[idx] != 'null' and nodes[idx] is not None:
            current.right = TreeNode(int(nodes[idx]))
            queue.append(current.right)
        idx += 1
    
    return root

# 读取输入并执行
if __name__ == "__main__":
    values = input().split()
    tree = buildTree([int(v) if v != 'null' else None for v in values])
    solution = Solution()
    print(solution.isSymmetric(tree))

import java.util.*;

public class Main {
    public class Solution {
        // 定义二叉树节点
        class TreeNode {
            int val;
            TreeNode left, right;
            TreeNode(int x) { val = x; }
        }

        // 判断是否是对称二叉树
        public boolean isSymmetric(TreeNode root) {
            if (root == null) return true;
            return isMirror(root.left, root.right);
        }

        // 递归检查两个子树是否镜像对称
        private boolean isMirror(TreeNode left, TreeNode right) {
            if (left == null && right == null) return true;
            if (left == null || right == null) return false;
            return (left.val == right.val) 
                && isMirror(left.left, right.right) 
                && isMirror(left.right, right.left);
        }

        // 辅助函数：根据数组构造二叉树
        public TreeNode buildTree(String[] nodes) {
            if (nodes.length == 0 || nodes[0].equals("null")) {
                return null;
            }
            
            // 构建根节点
            TreeNode root = new TreeNode(Integer.parseInt(nodes[0]));
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            int idx = 1;
            
            while (!queue.isEmpty() && idx < nodes.length) {
                TreeNode current = queue.poll();
                
                // 构建左子节点
                if (idx < nodes.length && !nodes[idx].equals("null")) {
                    current.left = new TreeNode(Integer.parseInt(nodes[idx]));
                    queue.offer(current.left);
                }
                idx++;
                
                // 构建右子节点
                if (idx < nodes.length && !nodes[idx].equals("null")) {
                    current.right = new TreeNode(Integer.parseInt(nodes[idx]));
                    queue.offer(current.right);
                }
                idx++;
            }
            
            return root;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] values = scanner.nextLine().split(" ");
        Main main = new Main();
        Solution solution = main.new Solution();
        Solution.TreeNode tree = solution.buildTree(values);
        System.out.println(solution.isSymmetric(tree));
    }
}

#include <iostream>
#include <vector>
#include <queue>
#include <sstream>
using namespace std;

// 二叉树节点定义
struct TreeNode {
    int val;
    TreeNode *left, *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (!root) return true;
        return isMirror(root->left, root->right);
    }

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

// 辅助函数：构造二叉树
TreeNode* buildTree(const vector<string>& nodes) {
    if (nodes.empty() || nodes[0] == "null") {
        return nullptr;
    }
    
    // 根节点
    TreeNode* root = new TreeNode(stoi(nodes[0]));
    queue<TreeNode*> q;
    q.push(root);
    int idx = 1;
    
    while (!q.empty() && idx < (int)nodes.size()) {
        TreeNode* current = q.front();
        q.pop();
        
        // 构建左子节点
        if (idx < (int)nodes.size() && nodes[idx] != "null") {
            current->left = new TreeNode(stoi(nodes[idx]));
            q.push(current->left);
        }
        idx++;
        
        // 构建右子节点
        if (idx < (int)nodes.size() && nodes[idx] != "null") {
            current->right = new TreeNode(stoi(nodes[idx]));
            q.push(current->right);
        }
        idx++;
    }
    
    return root;
}

int main() {
    string line;
    getline(cin, line);
    stringstream ss(line);
    vector<string> values;
    string val;
    while (ss >> val) values.push_back(val);
    Solution solution;
    TreeNode* root = buildTree(values);
    cout << (solution.isSymmetric(root) ? "true" : "false") << endl;
    return 0;
}