Day15(二叉树)|102. 二叉树的层序遍历

102. 二叉树的层序遍历

• 题目链接：102. 二叉树的层序遍历
• 解题思路：二叉树的层序遍历是按每层从左到右的顺序遍历，可以借助辅助队列的结构来实现，队列先进先出的特征符合一层一层遍历的逻辑，而栈先入后出的模式符合深度优先的逻辑。
• 主要难点：辅助队列的使用
• 解题步骤：
  • 先将根部节点入队，然后循环当队列不为空时，从队列中出元素放入结果数组，同时检查左右是否有子节点，有的话加入队列
• 解题时间：20+5
• 代码：

/**
 * 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>> res = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {
        levelTraversal(root);
        return res;
    }

    public void levelTraversal(TreeNode node){
        if(node==null){
            return;
        }
        //创建辅助队列
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(node);//把第一个节点放入队列(一般是根节点)

        while(!queue.isEmpty()){
            //用来存放一层的元素，每次加入到res中
            List<Integer> itemList = new ArrayList<Integer>();
            int len = queue.size();
            while(len>0){
                //从队列中出一个元素，将其值加入到itemlist中
                TreeNode tmp = queue.poll();
                itemList.add(tmp.val);
                //检查该节点左右是否不为空，若不为空则将左右元素加入队列
                if (tmp.left != null) queue.offer(tmp.left);
                if (tmp.right != null) queue.offer(tmp.right);
                len--;
            }
            res.add(itemList);
        }
    }
}

226. 翻转二叉树

• 题目链接：226. 翻转二叉树
• 解题思路：二叉树的整体反转是沿着树的中心线进行翻转，其实就是每个节点的左右孩子都进行了翻转，递归的翻转每个孩子的节点就可以完成
• 主要难点：递归的条件设置，递归的时候应该以什么顺序进行翻转？只有中序遍历不适合，因为以中序遍历的顺序去翻转会使一些节点翻了两次
• 解题时间：20+5
• 代码：

/**
 * 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.left);
        invertTree(root.right);
        change(root);
        return root;
    }
    private void change(TreeNode root){
        //交换左右孩子
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

101. 对称二叉树

• 题目链接：101. 对称二叉树
• 解题思路：对应位置比较，需要用到递归的思想去比
• 主要难点：比较的是什么？是对应位置上的值是否一样，内侧对应内侧，外侧对应外侧，不是单纯比较一个节点左右是否相等。用什么遍历顺序？只能用后序遍历方式，因为需要通过递归的返回值来比较是否相等，其实是某种回溯规则。
• 解题时间：20+5
• 代码：

/**
 * 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 compare(root.left,root.right);
    }
    private 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 inside = compare(left.right,right.left);
        boolean outside = compare(left.left,right.right);
        return inside&&outside;//内外比较都为true时才满足全部对称
    }
}

总结

• 今天的三道题都是二叉树的遍历比较问题，练习的是递归法的使用，需要判断递归结束条件以及每步递归的位置。