HOT100--Day14--543. 二叉树的直径，102. 二叉树的层序遍历，108. 将有序数组转换为二叉搜索树

HOT100–Day14–543. 二叉树的直径，102. 二叉树的层序遍历，108. 将有序数组转换为二叉搜索树

每日刷题系列。今天的题目是《力扣HOT100》题单。

题目类型：二叉树。

关键：要深刻理解《递归》

543. 二叉树的直径

思路：

自底向上遍历。

每个节点告诉上一层，从本节点出发到叶子节点的深度是多少。

每个节点，从左子树最深处走到右子树最深处，就是该节点的左右子树的高度相加，就是当前ans。

每个节点都要更新一次ans。

class Solution {
    private int res;

    public int diameterOfBinaryTree(TreeNode root) {
        dfs(root);
        return res;
    }

    // 自底向上遍历
    private int dfs(TreeNode node) {

        // 对于叶子来说，链长就是 -1+1=0
        if (node == null) {
            return -1;
        }

        // 探左右子树
        int lLen = dfs(node.left) + 1;
        int rLen = dfs(node.right) + 1;

        // 两条链拼成路径。每个节点都要更新最大值（直径）
        res = Math.max(res, lLen + rLen);

        // 把左右子树，长的那一条，返回给上一层
        return Math.max(lLen, rLen);
    }
}

102. 二叉树的层序遍历

思路：

利用队列进行层序遍历。（感觉像是BFS）

当前层的子节点加入队列之后，获取size。

下一层遍历size个节点。

这样就可以实现层序遍历了。

关键点：每层遍历size个。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> que = new ArrayDeque<>();
        que.offer(root);
        while (!que.isEmpty()) {
            List<Integer> list = new ArrayList<>();
            // 关键点：每层遍历size个
            int size = que.size();
            while (size-- > 0) {
                TreeNode cur = que.poll();
                list.add(cur.val);
                if (cur.left != null) {
                    que.offer(cur.left);
                }
                if (cur.right != null) {
                    que.offer(cur.right);
                }
            }
            res.add(list);
        }
        return res;
    }
}

108. 将有序数组转换为二叉搜索树

思路：

要记住，二叉搜索树是跟中序遍历强相关的。

采用分治的思想，递归处理。

对于每一段要处理的数据，找到它的中间点分为左和右。

中间点作为树根，它的左节点，递归到下一层处理[左，中)，右节点同理。

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return dfs(nums, 0, nums.length);
    }

    // 把 nums[left] 到 nums[right-1] 转成平衡二叉搜索树
    // [left,right)——左闭右开
    private TreeNode dfs(int[] nums, int left, int right) {

        // 指针重合，没有元素了，返回null
        if (left == right) {
            return null;
        }
        // 找到中间指针
        int m = (left + right) >> 1;

        // 中间处作为新节点，递归处理[左，中)和(中，右)   ps:中已经处理了
        return new TreeNode(nums[m], dfs(nums, left, m), dfs(nums, m + 1, right));
    }
}