代码随想录刷题训练营DAY14|层序遍历|226.翻转二叉树|101.对称二叉树

层序遍历

这里用图的广度优先搜索举例子。

根节点a开始访问，a先入队，此时队列非空，取出队头元素a，由于b，c与a邻接且未被访问过，于是依次访问b，c将b，c入队。







和BFS不一样的是，层次遍历需要让同一层的元素在一个list的里。

所以在BFS的基础上，还需要加一层while，把当前队列里的元素一起输出。

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

    public List<List<Integer>> levelOrder(TreeNode root) {
        if(root==null){
            return resList;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        //根节点入队
        queue.offer(root);
        while(!queue.isEmpty()){
            List<Integer> list=new ArrayList<>();
            int len=queue.size();//队列中元素表示在同一层
            
            while(len>0){
                //访问队列头元素
                TreeNode top=queue.poll();
                list.add(top.val);
                //访问队头元素的左右孩子
                if(top.left!=null){
                    queue.offer(top.left);
                }
                if(top.right!=null){
                    queue.offer(top.right);
                }
            len--;
            }
            resList.add(list);
        }   
        return resList;
    }
}

226.翻转二叉树

这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root==null){
            return null;
        }
		//左右中：后续遍历
        invertTree(root.left);
        invertTree(root.right);
        swapNode(root);
        return root;

    }

    //交换节点的方法
    public void swapNode(TreeNode root){
        TreeNode tmp=root.left;
        root.left=root.right;
        root.right=tmp;
    }
}

**

101.对称二叉树

**

思路：比较根节点的左右子树–>比较左右子树的里侧，外侧是否相同。

递归遍历：

• 左子树的遍历顺序是：左右中
• 右子树的遍历顺序是：右左中
  
  此处递归有几个退出条件的判断：
• 碰到左右子树有一个为空，肯定不用再判断其它了，直接false。
• 如果两个都为空了，说明递归结束了，是对称的。
• 如果两个值不一样，也false。
  比较左右子树的内外侧：
  左子树的外侧，左子树的左边；右子树的外侧，右子树的右边
  左子树的内测，左子树的右边；右子树的内测，右子树的左边

/**
 * 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);

    }
     public boolean compare(TreeNode left,TreeNode right){
          //情况1：左子树不空，右子树空
          if(left!=null&&right==null){
              return false;
          }
          //情况2：左子树空，右子树不空
          if(left==null&&right!=null){
              return false;
          }
          //情况3：左子树空，右子树空
          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);
          if(outside&&inside){
              return true;
          }else{
              return false;
          }
     }
}