【LeetCode】【HOT】226. 翻转二叉树（递归）

【LeetCode】【HOT】226. 翻转二叉树

package hot;

import java.util.ArrayDeque;
import java.util.ArrayList;

class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val){
        this.val = val;
    }
}

public class Solution226 {
    public static void main(String[] args) {
        TreeNode node1 = new TreeNode(4);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(7);
        TreeNode node4 = new TreeNode(1);
        TreeNode node5 = new TreeNode(3);
        TreeNode node6 = new TreeNode(6);
        TreeNode node7 = new TreeNode(9);
        node1.left = node2;
        node1.right = node3;
        node2.left = node4;
        node2.right = node5;
        node3.left = node6;
        node3.right = node7;
        Solution226 solution = new Solution226();
        System.out.println(solution.levelOrder(solution.method(node1)));
    }

    private TreeNode method(TreeNode root){
        if(root == null) return null;
        TreeNode left = method(root.left);
        TreeNode right = method(root.right);
        root.left = right;
        root.right = left;
        return root;
    }

    private ArrayList<Integer> levelOrder(TreeNode root){
        ArrayList<Integer> res = new ArrayList<>();
        ArrayDeque<TreeNode> queue = new ArrayDeque<>();
        TreeNode temp = new TreeNode(0);
        queue.add(root);
        while(!queue.isEmpty()){
            temp = queue.poll();
            res.add(temp.val);
            if(temp.left != null) queue.add(temp.left);
            if(temp.right != null) queue.add(temp.right);
        }
        return res;
    }
}

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