二叉树刷题 102. 二叉树的层序遍历 ｜ 199. 二叉树的右视图

二叉树

递归条件

要想递归，必须要满足3个条件：

• 确定递归方法的参数 、 返回值
• 确定边界条件
• 确定单层递归的逻辑

二叉树是计算机科学中的一种基本数据结构，与二叉树相关的一些常见公式包括：

1. 二叉树的节点数：对于任意一棵二叉树，如果其左子树有 L 个节点，右子树有 R 个节点，则整棵树有 L + R + 1 个节点。
2. 二叉树的高度：二叉树的高度可以通过递归定义。如果一棵二叉树为空，则其高度为 -1（有些定义中为空树的高度为 0）。如果树非空，其高度为 max(height of left subtree, height of right subtree) + 1。
3. 完全二叉树的性质：在完全二叉树中，如果从上到下、从左到右编号，那么每个节点的编号应该大于其左孩子的编号，并且小于或等于其右孩子的编号。完全二叉树的节点数 n 满足 2^(h+1) - 1 <= n <= 2^h - 1，其中 h 是树的高度。
4. 满二叉树的性质：一棵深度为 h 的满二叉树有 2^h - 1 个节点。
5. 平衡二叉树的性质：在任何平衡二叉树中（如AVL树），对于任何节点，其两个子树的高度最多相差1。
6. 二叉搜索树（BST）：在BST中，对于每个节点，其左子树上的所有节点的值都小于该节点的值，右子树上的所有节点的值都大于该节点的值。
7. 二叉树的遍历顺序：二叉树的遍历可以通过前序（Pre-order）、中序（In-order）、后序（Post-order）和层序（Breadth-first search, BFS）进行。
8. 树的序列化和反序列化：二叉树可以通过前序、中序、后序遍历的序列来序列化，并通过相应的算法来反序列化。
9. 树的直径：二叉树的直径是穿过树的最长路径的长度。它可以通过找到最深的两个节点并计算它们之间的路径长度来确定。
10. 树的重心：在二叉树中，重心是具有最小高度差的三个子树的根节点。重心的高度差的绝对值是最小的。

###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 {
    //create a double List
        public List<List<Integer>> resList = new ArrayList<List<Integer>>();

    // public void order(TreeNode node, int depth){
    //     if(node == null) return;
    //     depth++;
    //     if(resList.size() < depth){
    //         resList.add(new ArrayList<Integer>());
    //     }
    //     resList.get(depth-1).add(node.val);

    //     order(node.left,depth);
    //     order(node.right,depth);
    // }

    public void order(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);
        }

        }



    public List<List<Integer>> levelOrder(TreeNode root) {
        
        order(root);
        return resList;


    }
}

###199. 二叉树的右视图

/**
 * 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 {
    
    List<Integer> res = new ArrayList<>();

    public void order(TreeNode node, int depth){
        if(node == null) return;
        depth++;
        if(res.size() < depth){
            res.add(node.val);
        }
        if(node.right!=null)order(node.right,depth);
        if(node.left!=null)order(node.left,depth);
    }
    public List<Integer> rightSideView(TreeNode root) {
        order(root,0);
        return res;
    }
}