代码随想录刷题|LeetCode 226.翻转二叉树 101.对称二叉树

symdunstaz

已于 2022-10-26 16:17:53 修改

阅读量158

点赞数

分类专栏： LeetCode学习笔记文章标签： leetcode 算法 java 数据结构

于 2022-10-26 12:31:28 首次发布

本文链接：https://blog.csdn.net/m0_62575233/article/details/127530108

版权

LeetCode学习笔记专栏收录该内容

61 篇文章 0 订阅

订阅专栏

226.翻转二叉树

题目链接：力扣

思路

拿到翻转二叉树的时候看起来挺复杂的，但是仔细看就能看出，翻转二叉树其实就是将每个节点的左右节点进行交换(这是完成这道题的关键)

既然我们要交换每个节点的左右子节点，就要先对每个节点进行访问，然后再对每个节点的左右节点进行处理，这里跟为两步进行：访问节点和处理节点

处理节点简单，就是将节点的两个左右节点进行交换就可以了
访问节点就需要根据题目选择合适的遍历方法

递归法：使用递归法要做好递归的三部曲
迭代法(深度优先)：
迭代法(层序遍历)：只是在层序遍历的基础上添加了对节点的处理

做完这道题目的感觉：遍历二叉树的方式就那几种。首先你要审题，看题目是要干什么，然后根据题目原则合适的访问节点的方法(遍历二叉树)，因为二叉树的节点可能会因为处理节点发生改变，好的遍历方式是关键。然后在访问节点的过程中对节点进行处理就可以了

翻转二叉树

递归法

第一步：确定递归函数的参数和返回值
第二步：确定终止条件
第三步：确定单层的递归逻辑

/**
*采用前序遍历
*/
class Solution {
    public TreeNode invertTree(TreeNode root) {

        if (root == null) {
            return root;
        }

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

        return root;
    }
}

/**
*采用后序遍历
*/
class Solution {
    public TreeNode invertTree(TreeNode root) {

        if (root == null) {
            return root;
        }

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

        return root;
    }
}

迭代法

深度优先遍历(迭代法)

采用前序遍历的迭代法，其实迭代节点的方法都一样，就是看访问到节点之后怎么进行处理

// 采用前序遍历的迭代法
class Solution {
    public TreeNode invertTree(TreeNode root) {

        // 创建模拟栈
        Deque<TreeNode> stack = new ArrayDeque<>();

        // 先将根节点压栈
        stack.addFirst(root);

        while (!stack.isEmpty()) {
            // 先弹栈
            TreeNode node = stack.removeFirst();
            // 弹出来的元素交换左右子节点
            reverseNode(node);

            // 将右子树压栈
            if (node.right != null) {
                stack.push(node.right);
            }
            // 将左子树压栈
            if (node.left != null) {
                stack.push(node.left);
            }
        }

        return root;
        
    }

    public void reverseNode (TreeNode node) {
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
    }

    
}

层序遍历(迭代法)

只是再层序遍历的基础山添加了对节点的处理

/**
采用层序遍历
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {

        if (root == null) {
            return root;
        }

        Deque<TreeNode> queue = new ArrayDeque<>();

        queue.offer(root);

        while (!queue.isEmpty()) {
            int len = queue.size();
            while (len-- > 0) {
                // 先让队出队
                TreeNode node = queue.poll();

                // 交换其左右节点
                TreeNode temp = node.right;
                node.right = node.left;
                node.left = temp;

                // 将该节点的左右子节点入队
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }      
        }

        return root;
    }
}

101.对称二叉树

题目链接：力扣

思路

一开始做的时候想的是判断每个节点的左右节点如果是对称的就可以，这样的思路是错误的

比如这个对称二叉树，2下面的3和4是不对称的，但这是个对称二叉树

所以判断一个二叉树是不是对称二叉树，不应该是判断每个节点的左右节点是否相等，而是应该判断每个节点的左子树和右子树是否互为翻转二叉树

接下来我们要确定采取哪种遍历方式了：这道题目只能采用后序遍历，也就是说对中间节点的处理(判断左右两边是否互为翻转)，要从二叉树的最底层往上进行判断，所以需要对根节点的左子树采取左右中的遍历方式，同时对右子树采取右左中的遍历方式，才可以逐一进行比较

对称二叉树

递归法

因为要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两棵树，所以递归函数的参数是两棵树

这道题目的终止条件比较多，要把所有情况都涵盖了

比较外侧是否相等
比较内侧是否相等
收获结果

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left,root.right);
    }

    // 确定递归函数的参数和返回值
    public boolean compare(TreeNode left,TreeNode right) {

        if (left == null && right != null) {return false;}
        if (left != null && right == null) {return false;}
        if (left == null && right == null) {return true;}
        if (left.val != right.val) {return false;}

        // 比较外侧
        boolean outside = compare(left.left,right.right); // 左子树的左  右子树的右
        // 比较内侧
        boolean inside = compare(left.right,right.left);  // 左子树的右  右子树的左
        // 判断是否互为翻转
        return outside && inside; // 根节点  中
    }
}

迭代法

递归法本质上是从最下面往最上面进行检测
迭代法本质上是从最上面往最下面进行检测

需要注意的是，这个队列是可以添加空节点的，所以java中实现队列的时候要用LinkedList来实现，LinkedList是允许添加null元素的，其他实现类是不可以的

注意添加的顺序，一定是内侧和内侧一起添加，外侧和外侧一起添加

class Solution {
    public boolean isSymmetric(TreeNode root) {

        // 创建一个队列，用来存放内外侧的值，进行比较
        // 因为在下面添加节点的时候要添加空节点，所以要用LinkedList实现
        Deque<TreeNode> queue = new LinkedList<>();

        queue.offer(root.left);
        queue.offer(root.right);

        while (!queue.isEmpty()) {
            
            TreeNode leftnode = queue.poll();
            TreeNode rightnode = queue.poll();

            if (leftnode == null && rightnode == null) {
                continue;
            }
            if (leftnode == null || rightnode == null || leftnode.val != rightnode.val) {
                return false;
            }

            // 能来到这里的都是相等的
            // 再分别加入上两个节点的外侧和内侧节点
            // 加入外侧节点
            queue.offer(leftnode.left);
            queue.offer(rightnode.right);
            // 加入内侧节点
            queue.offer(leftnode.right);
            queue.offer(rightnode.left);
            
            
        }

        return true;
    }
}