算法-翻转二叉树

翻转二叉树

每个翻转一下就行了

 public TreeNode invertTree(TreeNode root) {
        if(root ==null){
            return null;
        }
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        invertTree(root.left);
        invertTree(root.right);
         return root;
    }

解法二、深度遍历，遍历后，交换即可

public TreeNode invertTree(TreeNode root) {
        if(root ==null){
            return null;
        }
        Queue<TreeNode> treeNodes = new LinkedList<>();
        treeNodes.offer(root);
        invert(treeNodes);
        return root;
    }

    private void invert(Queue<TreeNode> treeNodes) {
       while (!treeNodes.isEmpty()){
            TreeNode root =  treeNodes.poll();

           TreeNode temp = new TreeNode();
            temp = root.left;
            root.left = root.right;
            root.right = temp;

            if(root.left !=null){
                treeNodes.offer(root.left);
            }

            if(root.right !=null){
                treeNodes.offer(root.right);
            }

        }
    }

解法三、深度遍历

 /**
     * 深度优先遍历的方式反转
     */
    private TreeNode invertTreeByStack(TreeNode root) {
        if (root == null) {
            return null;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            int size = stack.size();
            for (int i = 0; i < size; i++) {
                TreeNode cur = stack.pop();
                TreeNode temp = cur.left;
                cur.left = cur.right;
                cur.right = temp;
                if (cur.right != null) {
                    stack.push(cur.right);
                }
                if (cur.left != null) {
                    stack.push(cur.left);
                }
            }
        }
        return root;
    }

这个算法其实就是考察遍历二叉树的