翻转二叉树

最新推荐文章于 2025-07-02 00:15:00 发布

原创最新推荐文章于 2025-07-02 00:15:00 发布 · 208 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #二叉树 #算法

Leetcode 同时被 2 个专栏收录

30 篇文章

订阅专栏

算法

25 篇文章

订阅专栏

肝胆相照，欲与天下共分秋月；
意气相许，欲与天下共坐春风；

Homebrew的作者Max Howell 应聘谷歌的面试题：226. Invert Binary Tree

吃瓜群众请点击这里:如何看待 Max Howell 被 Google 拒绝？

1. 翻转二叉树

226. 翻转二叉树

Given the root of a binary tree, invert the tree, and return its root.（给出一个二叉树的根节点，翻转此树并返回其根节点）

在这里插入图片描述

1.1 递归版本

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

1.2 非递归版本

1.2.1 非递归版本(基于Stack)

递归能解决的，我(栈)也能…（PS：我知道递归也是借助于 (隐形)栈 ）

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

       Stack<TreeNode> stack = new Stack<>();
       stack.push(root);

       while(!stack.isEmpty()){
           // 这里其实直接用pop就可以，但是考虑到其他语言，我还是这么写了
           TreeNode cur = stack.peek();
           stack.pop();

           TreeNode tmp = cur.left;
           cur.left = cur.right;
           cur.right = tmp;

           if(cur.left != null){
               stack.push(cur.left);
           }

           if(cur.right != null){
               stack.push(cur.right);
           }

       }
        return root;
    }
}

1.2.2 层次遍历(通用版)

这里为什么说是通用版本呢？因为除了翻转左右节点的代码需要特殊处理，这一套模版可以处理跟层次遍历相关的任何问题。（PS：没错的，是任何问题）

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) return root;
        
       Queue<TreeNode> queue = new LinkedList<>();
       queue.offer(root);
        
       while(!queue.isEmpty()){
           
          int size = queue.size();
           
           while(size -- > 0){
               TreeNode node = queue.poll();
               
               //翻转左右节点
               TreeNode right = node.right;
               node.right = node.left;
               node.left = right;
               
               if(node.left != null){
                   queue.offer(node.left);
               }
               
               if(node.right != null){
                   queue.offer(node.right);
               }
           }
           
       }
        return root;
    }
}

1.2.2.1 层次遍历(精简版)

由于翻转二叉树仅涉及到每一层的左右子树交换，跟层级的关系不大…

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null) return root;
        
       Queue<TreeNode> queue = new LinkedList<>();
       queue.offer(root);
        
       while(!queue.isEmpty()){
       
               TreeNode node = queue.poll();
               
               // 左右节点进行交换
               TreeNode right = node.right;
               node.right = node.left;
               node.left = right;
               
               if(node.left != null){
                   queue.offer(node.left);
               }
               
               if(node.right != null){
                   queue.offer(node.right);
               }
           
       }
        
       return root;
    }
}