代码随想录算法训练营day15| 层序遍历 , 226.翻转二叉树 ,101. 对称二叉树

102. 二叉树的层序遍历

package _06binary_tree.day15._01leveltravese;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {
    public List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> levelOrder(TreeNode root) {
        // 1、递归遍历
        // func(root, 0);

        // 2、非递归遍历（队列）
        func2(root);
        return res;
    }

    /**
     * 非递归遍历
     * @param node
     */
    private void func2(TreeNode node) {
        if(node == null) return;
        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(node);
        while (!queue.isEmpty()){
            List<Integer> leverList = new ArrayList<>();
            int len = queue.size(); // 当层节点数

            while (len > 0){
                TreeNode temp = queue.poll();
                leverList.add(temp.val);
                // 若左右孩子节点非空，入队
                if(temp.left!=null)queue.offer(temp.left);
                if(temp.right!=null)queue.offer(temp.right);

                len--; // 当层需访问节点数-1
            }

            res.add(leverList);
        }
    }

    /**
     * 递归遍历
     * @param node
     * @param depth
     */
    private void func(TreeNode node, Integer depth) {
        if (node == null) return; // 递归终止条件
        depth++;

        if (res.size() < depth) {
            // 记录每遍历一层的结果
            List<Integer> levelList = new ArrayList<>();
            // 添加该层的list(不是添加元素)
            res.add(levelList);
        }

        // 添加该层元素
        res.get(depth - 1).add(node.val);

        func(node.left, depth);
        func(node.right, depth);
    }
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }

    TreeNode(int val) {
        this.val = val;
    }

    TreeNode() {
    }
}

226. 翻转二叉树

package _06binary_tree.day15._02invert_tree;

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
    // DFS递归
    public TreeNode invertTree(TreeNode root) {
        if (root == null) return root;
        // 前序遍历
        swapChildren(root); // 中
        invertTree(root.left); // 左
        invertTree(root.right); // 右
        return root;

        // 后序遍历
        // invertTree(root.left);
        // invertTree(root.right);
        // swapChildren(root);
        // return root;
    }

    // BFS
    public TreeNode invertTree2(TreeNode root) {
        if (root == null) return root;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int len = queue.size();
            while (len > 0) {
                TreeNode node = queue.poll();
                swapChildren(node);
                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
                len--;
            }
        }
        return root;
    }

    private void swapChildren(TreeNode node) {
        TreeNode temp = node.left;
        node.left = node.right;
        node.right = temp;
    }
}

101. 对称二叉树

package _06binary_tree.day15._03is_symmetry;

import java.util.LinkedList;
import java.util.Queue;

public class Solution {
    // 递归
    public boolean isSymmetric1(TreeNode root) {
        if(root == null)return true;
        return compare(root.left,root.right);
    }

    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;
        // 此时，根节点的左右孩子值相同
        // 比较 左孩子的左孩子与右孩子的右孩子是否相等 && 左孩子的右孩子与右孩子的左孩子是否相等
        else return compare(left.left,right.right) && compare(left.right,right.left);
    }

    // 迭代法
    public boolean isSymmetric2(TreeNode root) {
        if(root == null)return true;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root.left);
        queue.offer(root.right);
        while (!queue.isEmpty()){
            TreeNode left = queue.poll();
            TreeNode right = queue.poll();
            if(left == null && right == null){
                continue;
            }
            if(left != null || right != null || left.val != right.val){
                return false;
            }

            queue.offer(left.left);
            queue.offer(right.right);
            queue.offer(left.right);
            queue.offer(right.left);
        }
        return true;
    }
}