代码随想录算法训练营第十五天 | Java |102层序遍历，226.翻转二叉树，101.对称二叉树

1 102. 二叉树的层序遍历

题目：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

提示：

• 树中节点数目在范围 [0, 2000] 内
• -1000 <= Node.val <= 1000

思路： 层序遍历属于广度遍历，一层一层从左至右遍历二叉树节点。借助队列记录每层的数据值，每层的队列单独保存到一个元素中。【我只用的迭代法，递归法有点没懂】

注意：有一个表记录每层的输出元素，有一个辅助队列记录当前层的元素。

Java实现

/**
 * 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>> reaList = new ArrayList<List<Integer>>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun(root);
        return reaList;
    }

    public void checkFun(TreeNode node){
        if(node==null){
            return ;
        }
        // 辅助数组
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(node);
        while(!que.isEmpty()){
            // 记录每层元素值表
            List<Integer> itemList = new ArrayList<>();
            int len = que.size();
            while(len>0){
                TreeNode curNode = que.poll();
                itemList.add(curNode.val);
                if(curNode.left!=null){
                    que.offer(curNode.left);
                }
                if(curNode.right!=null){
                    que.offer(curNode.right);
                }
                len--;
            }
            reaList.add(itemList);
        }
    }
}

2 226. 翻转二叉树

题目：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

提示：

• 树中节点数目范围在 [0, 100] 内
• -100 <= Node.val <= 100

思路：翻转二叉树，实质上就是调换每个节点的左右节点。

注意：遍历顺序要注意，迭代法用广度遍历实现，递归法用深度遍历（前序、后续遍历）。

Java实现

/**
 * 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 null;
    //     }
    //     invertTree(root.right);
    //     invertTree(root.left);
    //     swap(root);
    //     return root;
    // }

    // 广度遍历（层序遍历）迭代法，逐个左右对调
    public TreeNode invertTree(TreeNode root){
        if(root==null){
            return null;
        }
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.push(root);
        while(!deque.isEmpty()){
            int size = deque.size();
            while(size-- >0){
                TreeNode cur = deque.poll();
                swap(cur);
                if(cur.left!=null){
                    deque.push(cur.left);
                }
                if(cur.right!=null){
                    deque.push(cur.right);
                }
            }
        }
        return root;
    }

    public void swap(TreeNode node){
        TreeNode cur = node.left;
        node.left = node.right;
        node.right = cur;
    }
}

3 101. 对称二叉树

题目：给你一个二叉树的根节点 root ， 检查它是否轴对称。

提示：

• 树中节点数目在范围 [1, 1000] 内
• -100 <= Node.val <= 100

思路：首先要判断根节点下的左右节点是否都存在且数值相等，然后再执行递归，判断左右子树外侧和内侧是否对称。

注意：递归法中递归执行的位置很重要，在判断左右节点都存在且相等后再向下判断；迭代法入队时是一对一对入队的，便于判断和出队。

Java实现

/**
 * 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) {
        Queue<TreeNode> deque = new LinkedList<>();
        deque.offer(root.left);
        deque.offer(root.right);
        while(!deque.isEmpty()){
            TreeNode left = deque.poll();
            TreeNode right = deque.poll();
            if(left==null && right==null){
                continue;
            }
            if(left==null || right==null || left.val!=right.val){
                return false;
            }
            deque.offer(left.left);
            deque.offer(right.right);
            deque.offer(left.right);
            deque.offer(right.left);
        }
        return true;
    }

    // 递归法
    // private boolean compare(TreeNode left,TreeNode right){
    //     // 首先判断左右节点是否都不为空且值相同
    //     if(left!=null && right==null) return false;
    //     else if(left==null && right!=null) return false;
    //     else if(left==null && right==null) return true;
    //     else if(left.val!=right.val) return false;

    //     // 比较外侧
    //     boolean outside = compare(left.left,right.right);
    //     // 比较内侧
    //     boolean inside = compare(left.right,right.left);
    //     return outside && inside;
    // }
}