day15

LeetCode102: 层序遍历二叉树

package algor.trainingcamp;

import algor.junior_algor.tree.TreeNode;

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

/**
 * @author lizhe
 * @version 1.0
 * @description: 102. 二叉树的层序遍历
 *
 * 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
 * @date 2023/4/19 07:52
 */
public class LeetCode102_RE {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> resList = new ArrayList<>();
        Queue<TreeNode> queue = new LinkedList<>();
        if(null == root){
            return resList;
        }


        queue.add(root);

        while(!queue.isEmpty()){
            //单层数据
            int len = queue.size();
            List<Integer> subList = new ArrayList<>();
            while(len > 0){
                TreeNode poll = queue.poll();
                subList.add(poll.val);

                if(poll.left != null){
                    queue.add(poll.left);
                }

                if(poll.right != null){
                    queue.add(poll.right);
                }

                len--;
            }

            resList.add(subList);
        }
        return resList;
    }
}

LeetCode 226 翻转二叉树

* 不是翻转二叉树的值，而是翻转二叉树节点

package algor.trainingcamp;

import algor.junior_algor.tree.TreeNode;

/**
 * @author lizhe
 * @version 1.0
 * @description: 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
 * @date 2023/4/19 08:05
 *
 * 1. 确定递归的返回值 参数
 * 2. 确定终止条件
 * 3，处理逻辑
 */
public class LeetCode226 {
    public TreeNode invertTree(TreeNode root) {
        if(null == root){
            return root;
        }

        swap(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }

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

LeetCode 101 给定一个二叉树，检查它是否是镜像对称的。

package algor.trainingcamp;

import algor.junior_algor.tree.TreeNode;

/**
 * @author lizhe
 * @version 1.0
 * @description: 给定一个二叉树，检查它是否是镜像对称的。
 * @date 2023/4/19 08:14
 */
public class LeetCode101 {
    public boolean isSymmetric(TreeNode root) {
        if(null == root){
            return true;
        }

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