leetcode hot100_day03

目录

199.二叉树的右视图Medium

114.二叉树展开为链表Medium

---

199.二叉树的右视图Medium

看到题目后想到的就是昨天的层序遍历，直接在每层的最后一个节点处将该节点添加到集合中。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        //结果集合
        List<Integer> res = new ArrayList<>();
        //判空
        if(root == null)return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int currenr_level_Length = queue.size();
            for(int i = 0; i < currenr_level_Length; i++){
                TreeNode node = queue.poll();
                if(i == currenr_level_Length - 1){
                    res.add(node.val);
                }
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right !=null){
                    queue.offer(node.right);
                }
            }
        }
        return res;
    }
}

 第一次写有2点小错误，记一下：

1. 定义队列的时候没有说明类型，后面出队操作存储到node中时类型不能转换
2. 等于判断时是双等于
3. 判空的时候，如果说先判空返回的结果怎么都不对，先定义结果集合，root空就直接返回

题解里的DFS看一下，下次可以用这个方法：

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

    public List<Integer> rightSideView(TreeNode root) {
        dfs(root, 0); // 从根节点开始访问，根节点深度是0
        return res;
    }

    private void dfs(TreeNode root, int depth) {
        if (root == null) {
            return;
        }
        // 先访问 当前节点，再递归地访问 右子树 和 左子树。
        if (depth == res.size()) {   // 如果当前节点所在深度还没有出现在res里，说明在该深度下当前节点是第一个被访问的节点，因此将当前节点加入res中。
            res.add(root.val);
        }
        depth++;
        dfs(root.right, depth);
        dfs(root.left, depth);
    }
}

这个方法的遍历顺序和先序遍历的左右顺序正好相反，为根右左，这样就可以保证每次第一个访问到的是该层最右边的元素。res中的结果元素和深度对应，每层一个。目前还没怎么做DFS的题。

114.二叉树展开为链表Medium

 二叉树展开为链表 - 力扣（LeetCode），可以看一下这个题解。方法很多，感觉首先就理解错了题目的意思，要求是展开，应该是原地算法，你自己再构造一个不行。也行，就像题解那样获取前序序列后从根节点构造，你是又搞了个根节点，看清题目

看了题解就先用最简单的方法吧：

class Solution {
    List<TreeNode> pre_res= new ArrayList<>();
    public void flatten(TreeNode root) {
        preorder(root);
        TreeNode node = new TreeNode();
        node = root;
        int length = pre_res.size();
        for(int i = 1; i < pre_res.size(); i++){
            node.right = pre_res.get(i); 
            node.left = null;
            node = node.right;
        }
        return ;
    }
    private void preorder(TreeNode root){
        if(root == null)return ;
        pre_res.add(root);
        preorder(root.left);
        preorder(root.right);
    }
}

与官方主要的不同在for循环里，官方是拿到两个元素进行的操作，当时还不明白怎么返回的，应该是根据根节点的地址来判定的，就看这个地址存储的内容。

class Solution {
    public void flatten(TreeNode root) {
        List<TreeNode> list = new ArrayList<TreeNode>();
        preorderTraversal(root, list);
        int size = list.size();
        for (int i = 1; i < size; i++) {
            TreeNode prev = list.get(i - 1), curr = list.get(i);
            prev.left = null;
            prev.right = curr;
        }
    }

    public void preorderTraversal(TreeNode root, List<TreeNode> list) {
        if (root != null) {
            list.add(root);
            preorderTraversal(root.left, list);
            preorderTraversal(root.right, list);
        }
    }
}

这题磨磨蹭蹭的搞了好久，注意效率不会的及时看答案。