【力扣一刷】代码随想录day15（层序遍历10题、226.翻转二叉树 、101.对称二叉树 2）

已于 2024-03-24 00:33:47 修改
阅读量1k 收藏 29
点赞数 8
分类专栏： 力扣一刷打卡日记 文章标签： windows
于 2024-03-21 16:57:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46135891/article/details/136892218
版权

目录

【层序遍历10题】

【226.翻转二叉树】

A. 递归遍历

B. 迭代遍历（统一迭代法）

C、层序遍历

【101.对称二叉树 2】

【层序遍历10题】

层序遍历 & 递归遍历

  • 层序遍历：从上到下，从左到右，访问所有节点，对应BFS（广度优先搜索），利用队列实现。
  • 递归遍历：一直访问到最深的节点，然后回溯到它的父节点，遍历另一条路径，直到遍历完所有节点，对应DFS（深度优先搜索），利用递归/栈实现。

利用队列实现

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        Deque<TreeNode> queue = new ArrayDeque<>();
        List<List<Integer>> result = new ArrayList<>();

        if (root == null) return result;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            List<Integer> levelItem = new ArrayList<>();  // 存储当前层的所有节点的val
            int size = queue.size();  // 获取队列长度

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                levelItem.add(cur.val);
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            result.add(levelItem);
        }
        return result;
    }
}
  • 注意：不能直接将queue.size()直接放入for循环，因为queue长度在for循环内部会变

102自顶而下的层序遍历 + 反转List

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<TreeNode> queue = new ArrayDeque<>();

        if (root == null) return result;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            List<Integer> levelItem = new ArrayList<>();
            int size = queue.size();
            
            for(int i = 0; i < size; i++){
                cur = queue.poll();
                levelItem.add(cur.val);
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            result.add(levelItem);
        }
        Collections.reverse(result);
        return result;
    }
}

只需要记录当前层的最后一个元素

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        Deque<TreeNode> queue = new ArrayDeque<>();

        if (root == null) return result;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                cur = queue.poll();
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            result.add(cur.val); // 只需要记录当前层的最后一个元素
        }
        return result;
    }
}

对当前层的各个元素进行求和，最后除以队列的大小取均值

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        Deque<TreeNode> queue = new ArrayDeque<>();
        List<Double> result = new ArrayList<>();

        if (root == null) return result;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            double sum = 0; // 用于记录每层元素的和
            int size = queue.size();  // 获取队列长度

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                sum += cur.val;
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            result.add(sum / size);
        }
        return result;
    }
}

和模板题的思路一样，只不过访问子节点的时候要加一层循环

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<>();
        Deque<Node> queue = new ArrayDeque<>();

        if (root == null) return result;
        Node cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            List<Integer> levelItem = new ArrayList<>();
            int size = queue.size();
            
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                levelItem.add(cur.val);
                for (int j = 0; cur.children != null && j < cur.children.size(); j++){
                    queue.offer(cur.children.get(j));
                }
            }
            result.add(levelItem);
        }
        return result;
    }
}
  • 注意：List对象在获取size()时，习惯先判断是否为null，不为null再调用size()，如果为null调用size()会报空指针异常

在for循环内部比较，记录最大值

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        Deque<TreeNode> queue = new ArrayDeque<>();
        List<Integer> result = new ArrayList<>();

        if (root == null) return result;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            int max = queue.peek().val;  // 注意：返回的是节点，获取的是val值
            int size = queue.size();  // 获取队列长度

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                max = Math.max(max, cur.val);
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            result.add(max);
        }
        return result;
    }
}

为每一层最左边的节点虚构一个左边节点pre，让左边的节点pre指向当前节点cur，再将当前节点cur指定为下一个节点的左边节点pre

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        Deque<Node> queue = new ArrayDeque<>();
        if (root == null) return root;
        Node cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            int size = queue.size();  // 获取队列长度
            Node pre = new Node(); // 为每一层最左边的节点虚构一个前节点

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                pre.next = cur; // 让左边的节点指向当前节点
                pre = cur;  // 当前节点指定为下一个节点的左边节点
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            cur.next = null;  // 让当前层的最后一个节点指向null
        }
        return root;
    }
}

和116的代码一样，无论是完全二叉树还是普通的二叉树，利用队列的层序遍历，当前层的元素都能从左到右遍历

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        Deque<Node> queue = new ArrayDeque<>();
        if (root == null) return root;
        Node cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            int size = queue.size();  // 获取队列长度
            Node pre = new Node(); // 为每一层最左边的节点虚构一个前节点

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                pre.next = cur; // 让左边的节点指向当前节点
                pre = cur;  // 当前节点指定为下一个节点的左边节点
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            cur.next = null;  // 让当前层的最后一个节点指向null
        }
        return root;
    }
}

利用模板，每一层遍历完之后，深度+1

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        Deque<TreeNode> queue = new ArrayDeque<>();
        int result = 0;

        if (root == null) return result;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            int size = queue.size();  // 获取队列长度

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
            result++;
        }
        return result;
    }
}

如果遍历到一个节点没有左节点和右节点，那么该节点就是叶子节点，直接返回结果即可。

注意，要在遍历当前层之前更新当前深度。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        Deque<TreeNode> queue = new ArrayDeque<>();
        int result = 0;

        if (root == null) return result;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            int size = queue.size();  // 获取队列长度
            result++;  // 需要在遍历当前层之前更新当前深度

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                cur = queue.poll();
                  // 如果遍历到一个节点没有左节点和右节点，那么该节点就是叶子节点，直接返回结果即可
                if (cur.left == null && cur.right == null) return result;
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
        }
        return result;
    }
}

【226.翻转二叉树】

A. 递归遍历

1、确定方法的形参和返回值：直接用的是提供的方法，输入值和返回值都是root

2、确定终止条件：root=null则不需要反转，直接返回

3、确定单层递归逻辑：反转左右子树（递归实现）+左右子树互换，有点像动态优化的思路

方法一  递归（前序遍历）

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

        // 递归 - 前序遍历
        // 中
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        invertTree(root.left); // 左
        invertTree(root.right); // 右

        return root;
    }
}

方法二  递归（后序遍历）

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

        // 递归 - 后序遍历
        invertTree(root.left); // 左
        invertTree(root.right); // 右
        // 中
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;

        return root;
    }
}

方法三  递归（后序遍历）

注意：递归的【中序遍历】不能使用上面的模板，因为中序是左-中-右，左子树反转完，互换左右子树，再反转右子树，此时的右子树是由左子树互换过来的，无法完成题目的要求。

思路：可以反转左子树，互换左右子树，此时的左子树是原来没反转的右子树，继续反转左子树。

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

        // 递归 - 中序遍历
        invertTree(root.left); // 左

        // 中
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        
        invertTree(root.left); // 原来的右

        return root;
    }
}

B. 迭代遍历（统一迭代法）

思路：

  • cur不为null的时候，按指定的遍历方式对应的入栈顺序将节点和null入栈
  • cur为null的时候，获取栈顶（栈顶为当前访问的节点），互换该节点的左右子树

方法一  统一迭代（前序遍历）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        if (root == null) return root;

        TreeNode cur = root;
        stack.push(root);
        while(!stack.isEmpty()){
            cur = stack.pop();
            // cur不为null，前序遍历（中左右），入栈顺序：右-左-中-null
            if (cur != null){
                if (cur.right != null) stack.push(cur.right);
                if (cur.left != null) stack.push(cur.left);
                stack.push(cur);
                stack.push(null);
            }
            // cur为null，下一个弹出的节点即当前访问的节点，互换左右子树即可
            else{
                // 获取当前访问节点
                cur = stack.pop();

                // 互换当前节点的左右子树
                TreeNode tmp = cur.left;
                cur.left = cur.right;
                cur.right = tmp;
            }
        }
        return root;
    }
}

方法二  统一迭代（中序遍历）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        if (root == null) return root;

        TreeNode cur = root;
        stack.push(root);
        while(!stack.isEmpty()){
            cur = stack.pop();
            // cur不为null，中序遍历（左中右），入栈顺序：右-中-null-左
            if (cur != null){
                if (cur.right != null) stack.push(cur.right);
                stack.push(cur);
                stack.push(null);
                if (cur.left != null) stack.push(cur.left);
            }
            // cur为null，下一个弹出的节点即当前访问的节点，互换左右子树即可
            else{
                // 获取当前访问节点
                cur = stack.pop();

                // 互换当前节点的左右子树
                TreeNode tmp = cur.left;
                cur.left = cur.right;
                cur.right = tmp;
            }
        }
        return root;
    }
}

方法三  统一迭代（后序遍历）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        if (root == null) return root;

        TreeNode cur = root;
        stack.push(root);
        while(!stack.isEmpty()){
            cur = stack.pop();
            // cur不为null，后序遍历（左右中），入栈顺序：中-null-右-左
            if (cur != null){
                stack.push(cur);
                stack.push(null);
                if (cur.right != null) stack.push(cur.right);
                if (cur.left != null) stack.push(cur.left);
            }
            // cur为null，下一个弹出的节点即当前访问的节点，互换左右子树即可
            else{
                // 获取当前访问节点
                cur = stack.pop();

                // 互换当前节点的左右子树
                TreeNode tmp = cur.left;
                cur.left = cur.right;
                cur.right = tmp;
            }
        }
        return root;
    }
}

C、层序遍历

思路：队头节点弹出后，直接互换该节点的左右子树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode invertTree(TreeNode root) {
        Deque<TreeNode> queue = new ArrayDeque<>();

        if (root == null) return root;
        TreeNode cur = root;
        queue.offer(cur);

        while (!queue.isEmpty()){
            int size = queue.size();  // 获取队列长度

            // 遍历的次数由队列的长度决定
            for (int i = 0; i < size; i++){
                // 获取当前访问节点（队头节点）
                cur = queue.poll();

                // 反转当前节点的左右子树
                TreeNode tmp = cur.left;
                cur.left = cur.right;
                cur.right = tmp;

                // 将左右节点入队，为下一层的遍历做准备
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
        }
        return root;
    }
}

【101.对称二叉树 2】

方法一  递归（最简单，速度最快）

思路：创建递归方法

  • 1、确定参数和返回值
    • 参数：传入左右子树的root节点，两个节点都是TreeNode类型
    • 返回值：递归方法用于判断左右子树是否对称，返回类型为布尔值
  • 2、确定结束条件
    • 如果两个都为null，则对称，返回true
    • 如果只有其中一个为null，则不对称，返回false
    • 两个都不为null，则符合三个条件才是对称，即左右节点的值相等，左右节点对应的子树的内侧子树对称和外侧子树对称
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return judgeSymmetric(root.left, root.right);
    }

    public boolean judgeSymmetric(TreeNode left, TreeNode right){
        // 如果两个都为null，则对称，返回true
        if (left == null && right == null) return true;

        // 如果只有其中一个为null，则不对称，返回false
        if (left == null || right == null) return false;

        // 两个都不为null，则符合三个条件才是对称
        // 左右节点的值相等，左右节点对应的子树的内侧子树对称和外侧子树对称
        return right.val == left.val && judgeSymmetric(left.right, right.left) && judgeSymmetric(left.left, right.right);
    }
}

方法二  用两个队列遍历左右子树

思路：

1、创建两个队列，用于左子树和右子树的层序节点访问

2、将root节点的左右节点分别入队

3、循环判断左右子树是否对称

  • 排除特殊情况
    • 两个都为null，则不需要将左右节点存入队列，直接继续循环（continue）
    • 其中一个为null，左右子树对应位置的节点有一个不存在，直接返回false
    • 两个都不是null，左右子树对应位置的节点的值不相等，直接返回false
  • 访问左子树，左节点入队，再右节点入队
  • 访问右子树：右节点入队，再左节点入队

4、如果循环结束了，还没返回，证明左右子树对称，返回true

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        Deque<TreeNode> queue1 = new LinkedList<>();  // 左子树对应的队列
        Deque<TreeNode> queue2 = new LinkedList<>();  // 右子树对应的队列

        queue1.offer(root.left);
        queue2.offer(root.right);

        while (!queue1.isEmpty() && !queue2.isEmpty()){
            int size1 = queue1.size();

            // 一直都是size1 = size2，其中一个决定循环次数就行
            for (int i = 0; i < size1; i++){
                TreeNode cur1 = queue1.poll();
                TreeNode cur2 = queue2.poll();

                // 1、排除特殊情况
                // 两个都为null
                if (cur1 == null && cur2 == null) continue;
                
                // 其中一个为null
                if (cur1 == null || cur2 == null) return false;

                // 两个都不是null
                if (cur1.val != cur2.val) return false;

                // 2、访问左子树：先遍历左节点，再遍历右节点
                queue1.offer(cur1.left);
                queue1.offer(cur1.right);
                
                // 3、访问右子树：先遍历右节点，再遍历左节点
                queue2.offer(cur2.right);
                queue2.offer(cur2.left);
            }
        }
        return true; 
    }

}

方法三  优化方法二，只用一个队列

思路：

1、创建队列

2、将root节点的左右节点分别入队

3、循环判断左右子树是否对称

  • 排除特殊情况
    • 两个都为null，则不需要将左右节点存入队列，直接继续循环（continue）
    • 其中一个为null，左右子树对应位置的节点有一个不存在，直接返回false
    • 两个都不是null，左右子树对应位置的节点的值不相等，直接返回false
  • 将外侧节点入队
  • 将内侧节点入队

4、如果循环结束了，还没返回，证明左右子树对称，返回true

示例：

         1

       2  2

   3  4  4  3

56 78 87 65

队列变化情况：

【2，2】 -> 【3，3，4，4】-> 【5，5，6，6，7，7，8，8】

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        Deque<TreeNode> queue = new LinkedList<>();

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

        while (!queue.isEmpty()){
            int size = queue.size();

            for (int i = 0; i < size; i++){
                TreeNode cur1 = queue.poll();
                TreeNode cur2 = queue.poll();

                // 1、排除特殊情况
                // 两个都为null
                if (cur1 == null && cur2 == null) continue;
                
                // 其中一个为null
                if (cur1 == null || cur2 == null) return false;

                // 两个都不是null
                if (cur1.val != cur2.val) return false;

                // 2、外侧节点入队
                queue.offer(cur1.left); // 左子树的左节点
                queue.offer(cur2.right); // 右子树的右节点

                // 3、内侧节点入队
                queue.offer(cur1.right);  // 左子树的右节点
                queue.offer(cur2.left);  // 右子树的左节点
            }
        }
        return true; 
    }

}

weixin_46135891
关注
  • 8
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[力扣]144. 二叉树的前序遍历java
12-21
给定一个二叉树，返回它的前序遍历 示例: 思路 前序遍历1.先访问根节点，把元素加入到List中； 2.递归遍历左子树，把左子树的遍历结果加入到List中； 3.递归遍历右子树，把右子树的遍历结果加入到List中。 4.返回 ...
Python算法题源代码-LeetCode(力扣)-二叉树中的最大路径和
02-21
力扣热题Python源代码 题目：124. 二叉树中的最大路径和 二叉树中的 路径 被定义为一条节点序列，序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点，且不...
LeetCode 1379. 找出克隆二叉树中的相同节点（二叉树遍历）
12-21
给你两棵二叉树，原始树 original 和克隆树 cloned，以及一个位于原始树 original 中的目标节点 target。 其中，克隆树 cloned 是原始树 original 的一个 副本 。 请找出在树 cloned 中，与 target 相同 的节点，并...
【面试题8】二叉树的下一个节点
01-06
2.如果一个节点有右子树，下一个节点为右子树的最左结点； 3.如果一个节点无右子树，且为父节点的左子结点，下一个节点为父节点； 4.如果为父节点的右子节点，向上遍历直到找到其是父节点左子节点的结点 # -*- ...
力扣刷题 | 二叉树
12-20
文章目录总述基本概念二叉树性质二叉树遍历94 二叉树的中序遍历95 不同的二叉搜索树296 不同的二叉搜索树98 验证二叉搜索树100 相同的树101 对称二叉树102 二叉树的层序遍历103 二叉树的锯齿形层次遍历104 二叉树的...
单链表的应用（快慢指针）
Frenemy__的博客
05-16 218
对于链表类题，我们可以使用创建链表额外设值存值来避免创建链表通过多指针来改变链表的指向一种比较巧妙的方法-----快慢指针......
尝试编写一个不需要记忆的工具（以RecyclerView的Adapter为例）
乐征skyline
05-20 472
过去开发Android的时候，是一个非常常用的类，但是却用起来有些麻烦，于是就根据需要写了很多XXXAdapter之类的工具，也有很多开源可用的Adapter工具。如果只用一个，养成习惯后不成问题，但是如果比较多，就容易忘记或记错混淆。于是就有了一个想法：我能不能写一个不需要去记忆的工具，即便很长时间没用忘记了，也可以直接上手用。本文以为例，来分享我的思考和实现方式。
List接口的实现类（ ArrayList，LinkedList，Vector，Stack）
m0_57463864的博客
05-20 474
Vector是元老级别的类（JDK1.0），集合框架是JDK1.2开始才推出的概念，当时大部分程序员已经习惯Vector去存储数据，为了更好的推广集合框架和保留Vector，Java让Vector又多实现了List接口。​ LinkedList和ArrayList使用是一模一样的，这要归功于Conllection和List接口，因为接口是定义标准的！​ Vector和ArrayList使用是一模一样的，这要归功于Conllection和List接口，因为接口是定义标准的！
Java stream相关案例记录
qq_41157876的博客
05-20 186
现在有List<Person> list1和List<Person> list2，要求把名字相同的归在一起，并对年龄相加。3. 按照每个人的edu属性进行分组，value为这个edu组内的年龄和，返回Map<edu, sumAge>2. 按照每个人的edu属性进行分组，value为每个人的id，返回Map<edu, List<id>>1. 按照每个人的edu属性进行分组，返回Map<edu, List<User>>5. 先分组，再取value的第一个元素，返回Map<edu, User>
【数据结构】单链表逆置（详解）————四种方法
lzh20040919的博客
05-17 404
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
Java泛型类和方法声明
沉心ss的博客
05-20 76
【代码】Java泛型类和方法声明。
Linux基础-apt命令
洪源兄
05-20 577
这里记录一下我常用的apt命令。apt 是Linux下很强大的命令行软件包管理器， apt 提供软件包搜索，管理和信息查询等功能。它提供的功能与其他 APT 工具相同（像 apt-get 和 apt-cache），也也是说能用 apt-get 的场景其实用 apt 也能用。两者可以互换。
双向链表专题
Frenemy__的博客
05-17 907
相比于单链表来说，双向链表要遍历的地方少一些了，链表的节点的前一个节点也更好找，而不像单链表那样每找一个prev都要遍历链表，这也大大减少了我们的代码量；同时也使我们更容易地循环链表，为节省空间起到了作用，是我们用的更多的一个链表结构。
byzer plugin install log
gaohongfeng1的博客
05-20 507
3.修改byzer-lang下面conf目录的byzer.properties.override的streaming.plugin.clzznames。，支持本地文件系统，HDFS，对象存储。Byzer-lang 下载插件至数据湖目录，并热加载之。查看log文件，错误信息如下： 从日志看，是以为delta没有元数据。Byzer-lang 支持插件安装，删除，获取列表等。安装插件前，请配置 Byzer-lang 数据湖目录。若不指定插件类型，Byzer-lang 返回所有插件。会报错，提示目录不存在。
手撕LinkedList底层源码
qq_18879887的博客
05-15 326
一般项目中使用ArrayList居多，因为业务流程里查询业务是最多的。ArrayList 和 LinkedList效率的区别？LinkedList的底层数据结构是什么？添加功能 - 不扩容：ArrayList快。添加功能 - 扩容：LinkedList快。删除功能：LinkedList快。LinkedList：双向链表。修改功能：ArrayList快。查询功能：ArrayList快。ArrayList：一维数组。
实现单链表各种基本运算的算法
最新发布
About_Yu的博客
05-21 599
目的: 领会单链表存储结构和掌握单链表中各种基本运算算法设计，以及完成以下任务 编写头插法和尾插法编写代码，并且在main函数中使用头插法和尾插法进行实现导入数据。 内容: 编写一个程序linklist.cpp,实现单链表的各种基本运算和整体建表算法
Vsftpd 安装与配置
Ahern_的博客
05-20 374
注意：如需在Windows资源管理访问，需要在网络共享中心->Internet属性->高级，开启被动访问ftp（开启兼容模式）在 /etc/vsftpd/chroot_list 加入虚拟用户 zzh1 和 zzh2 ，每行对应一个虚拟用户。设置当前ftp存储目录用户权限、chroot_list 文件配置用户登录、设置虚拟用户。如果没有指定虚拟用户的ftp目录，默认访问目录就是ftp根目录 /u01/ftp/#赋予权限，测试直接赋予最高权限了，实际工作中建议在最小权限范围内满足即可。
@ApiModelProperty失效问题
沉心ss的博客
05-20 55
MybatisPlus生成模板，修改，set get方法的影响。
数据结构——线性表
2302_76516899的博客
05-20 869
线性表（List）是数据结构中的一种基本结构，是一组有序的数据元素的集合。线性表中的数据元素有且仅有一个前驱和一个后继（第一个元素没有前驱，最后一个元素没有后继）。线性表是实现其他数据结构（如堆栈、队列）的基础。顺序表（Sequential List）是一种线性表，其存储结构为一块连续的内存空间。顺序表通过数组来实现，数组中的每个位置都存储线性表的一个元素。链表（Linked List）是一种线性表，其存储结构为一组任意存储单元。链表中的每个元素称为结点（Node），每个结点包含数据域和指针域。
二叉树的层序遍历力扣
08-17
二叉树的层序遍历是一种广度优先搜索算法，通过逐层地从左到右访问所有节点，返回节点值的顺序。可以使用队列来实现层序遍历。具体思路如下： 1. 创建一个空的结果数组res和一个队列que，将根节点root放入队列que中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值