leetcode 二叉树的右视图

199. 二叉树的右视图

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

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

提示:

• 二叉树的节点个数的范围是 [0,100]
• -100 <= Node.val <= 100

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

• 广度优先搜索
  对二叉树每层进行遍历，每层的最后一个节点一定是二叉树的右视图节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        if (!root) return result;

        std::queue<TreeNode*> node_que;
        node_que.push(root);
        while (!node_que.empty()) {
            int que_size = node_que.size();
            for (int i = 0; i < que_size; ++i) {
                TreeNode* tmp = node_que.front();
                node_que.pop();
                if (i == que_size - 1) {
                    result.emplace_back(tmp->val);
                }
                if (tmp->left != nullptr) {
                    node_que.push(tmp->left);
                }
                if (tmp->right != nullptr) {
                    node_que.push(tmp->right);
                }
            }
        }

        return result;
    }
};

• 深度优先搜索
  在进行深度优先搜索的时候总是先访问右子树，那么在每个深度的第一个节点一定是我们的右视图节点。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> result;
        if (root == nullptr) return result;
        //DFS
        std::stack<TreeNode*> node_sta;
        std::unordered_map<int, int> tmp_result;
        std::stack<int> depth_sta;
        node_sta.push(root);
        depth_sta.push(0);
        int max_depth = 0;
        while (!node_sta.empty()) {
            TreeNode* tmp_node = node_sta.top();
            node_sta.pop();
            int depth = depth_sta.top();
            depth_sta.pop();
            if (tmp_node != nullptr) {
                max_depth = std::max(depth, max_depth);
                if (tmp_result.find(depth) == tmp_result.end()) {
                    tmp_result[depth] = tmp_node->val;
                }
                node_sta.push(tmp_node->left);
                depth_sta.push(depth + 1);
                node_sta.push(tmp_node->right);
                depth_sta.push(depth + 1);
            }
        }
        for (int depth = 0; depth <= max_depth; ++depth) {
            result.emplace_back(tmp_result[depth]);
        }
        return result;
    }
};