算法编程（Java）#二叉树翻转

问题描述

• 先定义一个二叉树

 public class TreeNode {
    int val; 
    TreeNode left;
    TreeNode right; 
    TreeNode(int x) { val = x; }
}

递归实现

思路：
1.判断根是否为空，根为空直接返回根；否则继续；
2.递归反转根的左右子树

 //递归方式
    public TreeNode invertTree(TreeNode root) {
        if (root == null) {
            return null;
        }

        //递归反转左右子树
        TreeNode temp = root.left;
        root.left = invertTree(root.right);
        root.right = invertTree(temp);

        return root;

    }

非递归层次遍历，借助栈

思路：

1.判断根是否为空，根为空直接返回根；否则继续；

2.交换根节点的左右子节点；

3. 交换第二层结点的左右子树；

4 重复下去，最后一个结点。

 public TreeNode invertTree2(TreeNode root) {
        if (root == null) {
            return null;
        }

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);//先将根节点压入堆栈
        while (stack.size() > 0) {
   			  //根据栈的先进后出操作，获取栈中最后一个元素，即最先入栈的元素
            TreeNode temp = stack.lastElement();
            stack.pop();//弹出栈顶元素

            //交换左右子树
            TreeNode tempLeft = temp.left;
            temp.left = temp.right;
            temp.right = tempLeft;

            //左子树不为空，将左子树入栈
            if (temp.left != null) {
                stack.push(temp.left);
            }
            //右子树不为空，将右子树入栈
            if (temp.right != null) {
                stack.push(temp.right);
            }
        }
        
        return root;

    }

非递归层次遍历，借助于队列，操作与栈类似，只不过元素是先进先出。

public TreeNode invertTree3(TreeNode root) {
        if (root == null) {
            return null;
        }

        //LinkedList实现了集合框架的Queue接口
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);//加入元素
        while (queue.size() > 0){
            TreeNode temp = queue.poll();//获取并移出元素

            TreeNode tempLeft = temp.left;
            temp.left = temp.right;
            temp.right = tempLeft;

            if (temp.left != null){
                queue.offer(temp.left);
            }
            if (temp.right != null){
                queue.offer(temp.right);
            }
        }

        return root;
    }