代码随想录算法训练营第十四天|二叉树层序遍历,LeetCode226,101

代码随想录算法训练营第十四天|二叉树层序遍历,LeetCode226,101

层序遍历

借助队列，保存每层遍历过的元素，队列的size就代表二叉树这一层有多少元素

队列模拟过程：

初始阶段：将根节点加入队列：

迭代阶段：新建一个队列大小的List。将队列中的元素弹出并记录到List中。同时，每弹出一个元素将他的左右非空子节点加到队列中。

结束阶段：队列为空，结束。

    //列用队列进行迭代
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList<>();

        //队列
        ArrayDeque<TreeNode> que = new ArrayDeque<>();
        if (root!=null){
            que.add(root);
        }
        while (!que.isEmpty()){
            List<Integer> level = new ArrayList<>();
            int len = que.size();
            for (int i = len; i>0;i--){
                TreeNode tmp = que.remove();
                level.add(tmp.val);
                if (tmp.left != null) que.add(tmp.left);
                if (tmp.right!=null) que.add(tmp.right);
            }
            result.add(level);
        }
        return result;

    }

226.翻转二叉树

翻转二叉树，可以通过翻转每一个节点的左右子节点来实现
确定需要采用的遍历方式。这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次
使用递归或者迭代法均可以实现

//递归
 public TreeNode invertTree(TreeNode root) {
        if (root == null){
            return root;
        }
        swap(root);//swap放到这为前序遍历
        invertTree(root.left);
        invertTree(root.right);
        return root;
        //swap(root);//swap放到这为后序遍历
    }

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

    }

    //迭代
    public TreeNode invertTree(TreeNode root) {
        ArrayDeque<TreeNode> stack = new ArrayDeque<>();
        if (root!= null){
            stack.push(root);
        }
        while (!stack.isEmpty()){
            TreeNode tmp = stack.pop();
            swap(tmp);
            if (tmp.right!=null) stack.push(tmp.right);
            if (tmp.left != null) stack.push(tmp.left);
        }

    return root;
    }

101.对称二叉树

对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，所以在递归遍历的过程中，也是要同时遍历两棵树。
本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中。

1. 确定递归函数的参数和返回值

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

返回值自然是bool类型。

2. 确定终止条件

要比较两个节点数值相不相同，首先要把两个节点为空的情况弄清楚！否则后面比较数值的时候就会操作空指针了。

节点为空的情况有：（注意我们比较的其实不是左孩子和右孩子，所以如下我称之为左节点右节点）

• 左节点为空，右节点不为空，不对称，return false
• 左不为空，右为空，不对称 return false
• 左右都为空，对称，返回true

此时已经排除掉了节点为空的情况，那么剩下的就是左右节点不为空：

• 左右都不为空，比较节点数值，不相同就return false

此时左右节点不为空，且数值也不相同的情况我们也处理了。把以上情况都排除之后，剩下的就是 左右节点都不为空，且数值相同的情况。

3. 确定单层递归的逻辑

此时才进入单层递归的逻辑，单层递归的逻辑就是处理 左右节点都不为空，且数值相同的情况。

• 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
• 比较内测是否对称，传入左节点的右孩子，右节点的左孩子。
• 如果左右都对称就返回true ，有一侧不对称就返回false 。

public boolean isSymmetric(TreeNode root) {
        if (root == null){
            return false;
        }
        return compare(root.left,root.right);

    }

    public 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;

    }