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

链接：代码随想录

文章目录  

• 102.二叉树的层序遍历
• 226.翻转二叉树
• 101.对称二叉树
• 解题方法
  • 题目思路
  • 示例代码
• 总结

---

解题思路

1.102.二叉树的层次遍历 解题思路

递归法，创立二维数组，每行填入相同层数的结点；迭代法采用队列的方法，同时使用size[]数组来记录队列个数，每次满足每层结点数时，向下一次迭代。

代码如下（示例）：

//递归
class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {  //建立矩阵，二维数组
        checkFun01(root,0);
        return resList;
    }
    public void checkFun01(TreeNode node,Integer deep){
        if(node==null) return;

        deep++;
        if(resList.size() < deep){
            List<Integer> item = new ArrayList<Integer>();   //增加行数
            resList.add(item);
        }
        resList.get(deep-1).add(node.val);    //每行添加元素

        checkFun01(node.left,deep);
        checkFun01(node.right,deep);
    }
}
//迭代
class Solution {
    public List<List<Integer>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrder(TreeNode root) {    //设立矩阵
        checkFun01(root);
        return resList;
    }
    public void checkFun01(TreeNode node){  
        if(node == null) return;
        Queue<TreeNode> que = new LinkedList<TreeNode>();//用队列实现
        que.offer(node);
        while(!que.isEmpty()){
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();

            while(len > 0){
                TreeNode tmpNode = que.poll();  //弹出元素直至每层结束
                itemList.add(tmpNode.val);

                if(tmpNode.left!=null) que.offer(tmpNode.left);
                if(tmpNode.right!=null) que.offer(tmpNode.right);
                len--;
            }
            resList.add(itemList);
        }
    }
}

2.226.翻转二叉树 解题思路

直接交换所有的左右结点即可达到镜像的效果，注意不能采用中序遍历，因为会导致前面的左右结点不发生交换，而前序、后序、层序遍历可以满足题意。

代码如下（示例）：

//迭代法
class Solution {
     public TreeNode invertTree(TreeNode root) {
        if (root == null) {return null;}   //返回条件
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();  //采用队列
        deque.offer(root);
        while (!deque.isEmpty()) {    
            int size = deque.size();  
            while (size-- > 0) {
                TreeNode node = deque.poll();
                swap(node);
                if (node.left != null) {deque.offer(node.left);}
                if (node.right != null) {deque.offer(node.right);}
            }
        }
        return root;
    }

    public void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

//递归法

​class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root);
        return root;
    }
    private void swapChildren(TreeNode root){  //交换两结点
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
    }
}

 

3.101.对称二叉树 解题思路

不需要考虑根结点，然后从外测到内测一一对应相等即可

代码如下（示例）：

//递归法
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 compareOut = compare(left.left,right.right);
        boolean compareIn = compare(left.right,right.left);
        return compareOut&&compareIn;
    }
}

 

---

总结 

递归法易理解难单独写，迭代法好像都挺难的/("▔□▔")\