【中等】199-二叉树的右视图 Binary Tree Right Side View

题目

Given a binary tree, imagine yourself standing on the right side of it, return the values of the nodes you can see ordered from top to bottom.

给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

Example:

Input: [1,2,3,null,5,null,4]
Output: [1, 3, 4]
Explanation:

   1            <---
 /   \
2     3         <---
 \     \
  5     4       <---

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-right-side-view

解法

方法一：层次遍历/广度优先搜索

解题思路

很明显题目是要我们找到每一层上面最右侧的节点，所以只需要层次遍历结构树，把每一层最右侧的节点取到即可

代码

代码一：非递归

// 使用一个map用来记录每一层的最右侧数
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if(root == NULL) return res;
        map<int, int> depth_map; // 层数与最右侧值的映射
        queue<TreeNode*> nums;
        queue<int> depth;
        int max_depth = -1; // 最深层次数
        nums.push(root);
        depth.push(0);
        while(!nums.empty()){
            int d = depth.front(); depth.pop();
            TreeNode* curr = nums.front(); nums.pop();
            depth_map[d] = curr->val; // 当前层次的最右侧设置为当前值，这个值在不断被更新
            max_depth = d > max_depth ? d : max_depth;
            if(curr->left){
                nums.push(curr->left);
                depth.push(d+1);
            } 
            if(curr->right){
                nums.push(curr->right);
                depth.push(d+1);
            }
        }
        for(int i = 0; i < max_depth+1; ++i){
            res.push_back(depth_map[i]);
        }
        return res;
    }
};

代码二：递归

// 记录每一层的节点数，取最后一个即可
class Solution {
public:
    void checkRight(queue<TreeNode*> level, vector<int>& res){
        int size = level.size();
        if(size == 0) return;
        for(int i = 0; i < size; ++i){
            TreeNode* curr = level.front();
            if(i == size -1) res.push_back(curr->val); // 每层迭代开始前
            if(curr->left != NULL) level.push(curr->left);
            if(curr->right != NULL) level.push(curr->right);
            level.pop();
        }
        checkRight(level, res);
    }
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if(root == NULL) return res;
        queue<TreeNode*> nums;
        nums.push(root);
        checkRight(nums, res);
        return res;
    }
};

方法二：深度优先搜索

解题思路

对于每一条自上向下的分支进行深度优先搜索，仍旧使用一个map<int, int>保存每次搜索的深度数据，如果是自右向左搜索，那么如果在搜索某条分支时某深度已经有数据，就说明当前分支的右侧已经有分支覆盖了这一深度，就不进行存储；如果是自左向右搜索，就对map每轮都进行赋值。

（广度优先搜索同理，如果是自右向左搜索，那map的赋值也不能覆盖）

代码

代码一：递归

// 自右向左搜索
class Solution {
public:
    void checkRight(TreeNode* node, int depth, int& max_depth, map<int, int>& depth_map){
        if(depth_map.find(depth) == depth_map.end()){ 
            depth_map[depth] = node->val;
            max_depth = max_depth > depth ? max_depth : depth;
        }
        if(node->right) checkRight(node->right, depth+1, max_depth, depth_map);
        if(node->left) checkRight(node->left, depth+1, max_depth, depth_map);
    }
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if(root == NULL) return res;
        map<int, int> depth_map;
        int max_depth = -1;
        checkRight(root, 0, max_depth, depth_map);
        for(int i = 0; i < max_depth+1; ++i){
            res.push_back(depth_map[i]);
        }
        return res;
    }
};

代码二：非递归

// 自左向右
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> res;
        if(root == NULL) return res;
        map<int, int> depth_map;
        stack<TreeNode*> nums; nums.push(root);
        stack<int> depth; depth.push(0);
        int max_depth = -1;
        while(!nums.empty()){
            int d = depth.top(); depth.pop();
            TreeNode* curr = nums.top(); nums.pop();
            depth_map[d] = curr->val;
            max_depth = d > max_depth ? d : max_depth;
            if(curr->right){
                nums.push(curr->right);
                depth.push(d+1);
            } 
            if(curr->left){
                nums.push(curr->left);
                depth.push(d+1);
            }
        }
        for(int i = 0; i < max_depth+1; ++i){
            res.push_back(depth_map[i]);
        }
        return res;
    }
};