leetcode：226. 翻转二叉树

题目来源

面试题27. 二叉树的镜像

226. 翻转二叉树

题目描述

题目解析

使用递归

• java

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null){
            return null;
        }

        TreeNode left = mirrorTree(root.left);
        TreeNode right = mirrorTree(root.right);
        root.right = left;
        root.left = right;
        return root;
    }
}

• golang：

func mirrorTree(root *TreeNode) *TreeNode {
	if root  == nil {
		return nil
	}

	ok := &TreeNode{Val:   root.Val,}
	ok.Right = mirrorTree(root.Left)
	ok.Left = mirrorTree(root.Right)

	return ok
}

• cpp

前序遍历

由于我们对父节点的操作和对孩子节点的操作是一样的，所以可以采取递归的方式，我们可以先交换两个节点再进入两个孩子（先序优先遍历），也可以进入两个孩子之后再交换两个节点（后序优先遍历）。但是如果我们想要使用中序优先遍历的话，就需要做些调整，比如我们先进入左孩子再交换两个孩子，此时如果我们进入右孩子的话，其实我们进入的就是左孩子，因为刚刚进行了交换，所以我们任然需要进入左孩子。

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null){
            return null;
        }

        TreeNode treeNode = root.left;
        root.left = root.right;
        root.right = treeNode;
        
        
        invertTree(root.left);
        invertTree(root.right);
        
        return root;
    }
}

TreeNode* invertTree(TreeNode* root) {
    if(root == NULL){
        return NULL;
    }
    
    TreeNode *bk = root->left;
    root->left = root->right;
    root->right = bk;
    
    invertTree(root->left);
    invertTree(root->right);
    
    return root;
}

中序遍历

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

        invertTree(root.left);

        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;

        // 注意：因为左右子树已经交换了，因此这里不能写 invertTree(root.right);
        // 即：这里的 root.left 就是交换之前的 root.right
        invertTree(root.left);
        return root;
    }

后序遍历

public class Solution {

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

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

        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        return root;
    }
}

辅助栈

• 特例处理： 当 root 为空时，直接返回 null；
• 初始化：初始化一个栈，并加入根节点 root。
• 循环交换： 当栈 stack 为空时跳出；
• 出栈： 记为 node ；
• 交换： 交换 node的左 / 右子节点。
• 添加子节点：如果node的左右节点不为空， 将 node左和右子节点入栈；
• 返回值： 返回根节点 root。

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null){
            return null;
        }

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.empty()){
            TreeNode pop = stack.pop();
            TreeNode temp = pop.left;
            pop.left = pop.right;
            pop.right = temp;
            if (pop.left != null){
                stack.push(pop.left);
            }
            
            if (pop.right != null){
                stack.push(pop.right);
            }
        }
        return root;
    }
}

使用队列

思路同上

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if (root == null){
            return null;
        }

        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            TreeNode treeNode = queue.pop();
            TreeNode temp = treeNode.left;
            treeNode.left = treeNode.right;
            treeNode.right = temp;
            if (treeNode.left != null){
                queue.offer(treeNode.left);
            }
            if (treeNode.right != null){
                queue.offer(treeNode.right);
            }
        }
        return root;
    }
}