4 3 7 1 3 6 9

4 7 2 9 6 3 1

2 1 3

2 3 1

# 定义二叉树节点
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

class Solution:
    # 翻转二叉树的递归方法
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return None
        # 递归翻转左右子树
        left_inverted = self.invertTree(root.left)
        right_inverted = self.invertTree(root.right)
        # 交换左右子树
        root.left, root.right = right_inverted, left_inverted
        return root

def build_tree(level_order):
    if not level_order or level_order[0] == 'null':
        return None
    
    root = TreeNode(int(level_order[0]))
    queue = [root]
    i = 1
    while i < len(level_order):
        current = queue.pop(0)
        # 构造左子节点
        if i < len(level_order) and level_order[i] != 'null':
            current.left = TreeNode(int(level_order[i]))
            queue.append(current.left)
        i += 1
        # 构造右子节点
        if i < len(level_order) and level_order[i] != 'null':
            current.right = TreeNode(int(level_order[i]))
            queue.append(current.right)
        i += 1
    return root

if __name__ == "__main__":
    import sys
    from collections import deque
    
    # 读取输入，输入为一行，节点值之间用空格分隔
    line = sys.stdin.read().strip()
    if not line:
        sys.exit(0)
    vals = line.split()
    
    root = build_tree(vals)
  
    # 调用翻转二叉树函数
    sol = Solution()
    inverted_root = sol.invertTree(root)
    
    # 层序遍历翻转后的二叉树并输出结果
    res = []
    queue = deque([inverted_root])
    while queue:
        node = queue.popleft()
        res.append(str(node.val))
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    
    print(" ".join(res))

import java.util.*;

// 主类
public class Main {
    // 内部 Solution 类封装解题逻辑
    public class Solution {
        // 定义二叉树节点
        public class TreeNode {
            int val;
            TreeNode left;
            TreeNode right;
            TreeNode(int x) {
                val = x;
            }
        }
        
        // 翻转二叉树的递归方法
        public TreeNode invertTree(TreeNode root) {
            if (root == null) {
                return null;
            }
            // 递归翻转左右子树
            TreeNode leftInverted = invertTree(root.left);
            TreeNode rightInverted = invertTree(root.right);
            // 交换左右子树
            root.left = rightInverted;
            root.right = leftInverted;
            return root;
        }
        
        // 根据层次遍历构造二叉树
        public static TreeNode buildTree(String[] tokens) {
            if (tokens.length == 0 || tokens[0].equals("null"))
                return null;
            
            TreeNode root = new TreeNode(Integer.parseInt(tokens[0]));
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            int i = 1;
            while (i < tokens.length) {
                TreeNode current = queue.poll();
                // 构造左子节点
                if (i < tokens.length && !tokens[i].equals("null")) {
                    current.left = new TreeNode(Integer.parseInt(tokens[i]));
                    queue.offer(current.left);
                }
                i++;
                // 构造右子节点
                if (i < tokens.length && !tokens[i].equals("null")) {
                    current.right = new TreeNode(Integer.parseInt(tokens[i]));
                    queue.offer(current.right);
                }
                i++;
            }
            return root;
        }
        
        // 层序遍历二叉树并返回结果字符串
        public String levelOrder(TreeNode root) {
            if (root == null) return "";
            StringBuilder sb = new StringBuilder();
            Queue<TreeNode> queue = new LinkedList<>();
            queue.offer(root);
            while (!queue.isEmpty()) {
                TreeNode cur = queue.poll();
                sb.append(cur.val).append(" ");
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
            return sb.toString().trim();
        }
    }
    
    public static void main(String[] args) {
        // 读取输入
        Scanner sc = new Scanner(System.in);
        String line = "";
        if(sc.hasNextLine()){
            line = sc.nextLine().trim();
        }
        sc.close();
        
        if(line.length() == 0) return;
        
        String[] arr = line.split("\\s+");
        Main main = new Main();
        Solution solution = main.new Solution();
        // 构造二叉树
        Solution.TreeNode root = solution.buildTree(arr);
        // 翻转二叉树
        Solution.TreeNode invertedRoot = solution.invertTree(root);
        // 输出翻转后的层序遍历结果
        System.out.println(solution.levelOrder(invertedRoot));
    }
}

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

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

class Solution {
public:
    // 翻转二叉树的递归方法
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return nullptr;
        // 递归翻转左右子树
        TreeNode* leftInverted = invertTree(root->left);
        TreeNode* rightInverted = invertTree(root->right);
        // 交换左右子节点
        root->left = rightInverted;
        root->right = leftInverted;
        return root;
    }
};

// 根据层次遍历结果构造二叉树
TreeNode* buildTree(const vector<string>& tokens) {
    if (tokens.empty() || tokens[0] == "null")
        return nullptr;
    
    TreeNode* root = new TreeNode(stoi(tokens[0]));
    queue<TreeNode*> q;
    q.push(root);
    int i = 1;
    while (i < tokens.size()) {
        TreeNode* current = q.front();
        q.pop();
        // 构造左子节点
        if (i < tokens.size() && tokens[i] != "null") {
            current->left = new TreeNode(stoi(tokens[i]));
            q.push(current->left);
        }
        i++;
        // 构造右子节点
        if (i < tokens.size() && tokens[i] != "null") {
            current->right = new TreeNode(stoi(tokens[i]));
            q.push(current->right);
        }
        i++;
    }
    return root;
}

// 层序遍历二叉树并输出结果
void levelOrder(TreeNode* root) {
    if (root == nullptr) return;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        cout << node->val << " ";
        if (node->left) q.push(node->left);
        if (node->right) q.push(node->right);
    }
}

int main(){
    string line;
    getline(cin, line);
    if(line.empty()) return 0;
    istringstream iss(line);
    vector<int> vals;
    int num;
    while(iss >> num) {
        vals.push_back(num);
    }
    
    // 构造二叉树
    TreeNode* root = buildTree(vals);
    Solution solution;
    // 翻转二叉树
    TreeNode* invertedRoot = solution.invertTree(root);
    // 层序遍历输出结果
    levelOrder(invertedRoot);
    return 0;
}