算法训练day15-二叉树层序翻转对称

102.二叉树的层序遍历

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

思路：利用队列先进先出的特性来实现层序遍历

代码实现

/**
 * 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) {
        List<List<Integer>>  result = new ArrayList<>();
       // 判空
       if(root==null){
           return result;
       }
       // 迭代法队列实现
       Queue<TreeNode> que = new LinkedList<TreeNode>();
       que.offer(root);
       while(!que.isEmpty()){
          List<Integer> list = new ArrayList<>();
          int len = que.size();
          while(len>0){
              TreeNode tempNode = que.poll();
              list.add(tempNode.val);
              if(tempNode.left!=null){
                  que.offer(tempNode.left);
              }
              if(tempNode.right!=null){
                  que.offer(tempNode.right);
              }
              len--;
          }
          result.add(list);
       }
       
       return result;
    }
}

226.翻转二叉树

给你一棵二叉树的根节点 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 null;
       }
       swap(root);
       invertTree(root.left);
       invertTree(root.right);
       return root;
    }
    private void swap(TreeNode root){
       TreeNode tempNode = root.left;
       root.left = root.right;
       root.right = tempNode;
    }
}

101.对称二叉树

给你一个二叉树的根节点 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 boolean isSymmetric(TreeNode root) {
        return compare(root.left,root.right);
    }
    private boolean compare(TreeNode left,TreeNode right){
      //特殊情况判断
      if((left==null&&right==null)){
        return true;
      }
      if((left==null||right==null)){
        return false;
      }
      if(left.val!=right.val){
          return false;
      }
      // 比较外侧
      boolean copmareout =  compare(left.left,right.right);
      // 比较内测
      boolean comparein = compare(left.right,right.left);
      return comparein && copmareout;
    }
}