九号球普通 2023年11月19日下午10:20

“`java
每一层找出最右侧的即可
class Solution {
public List rightSideView(TreeNode root) {
if (root == null) {
return new ArrayList<>();
}
List res = new ArrayList<>();
Queue queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
int n = queue.size();
for (int i = 0; i < n; i++) { TreeNode node = queue.poll(); if (i == n - 1) { res.add(node.val); } if (node.left != null) { queue.add(node.left); } if (node.right != null) { queue.add(node.right); } } } return res; } }

0 赞同 0 条回复

招舟子普通 2023年8月26日下午9:03

“`java
class Solution {
public List rightSideView(TreeNode root) {
if(root==null){
return new ArrayList();
}
List l = new ArrayList();
Queue q = new LinkedList();
q.offer(root);
while(!q.isEmpty()){
int s = q.size();

        for(int i=0;i<s;i++){
            TreeNode node  = q.poll();
            if(i==s-1){
                l.add(node.val);
            }
        if(node.left!=null){q.offer(node.left);}
        if(node.right!=null){q.offer(node.right);}
        }
    }
    return l;
}

}
使用层序遍历

0 赞同 0 条回复

jhfuture 普通 2023年8月16日下午10:56

“`java
使用官方的广度优先算法
/**
* 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 {
public List rightSideView(TreeNode root) {
List result=new ArrayList();
if(root==null ) return result;
// 改用广度优先算法。
// 1.遍历每一层，然后拿出最后一个
Queue q= new LinkedList();
q.add(root);

        while(!q.isEmpty()){
            int size=q.size();
            for(int i=0;i<size;i++){
            TreeNode t=q.poll();
            if(t.left!=null){
                q.add(t.left);
            }
            if(t.right!=null){
                q.add(t.right);
            }
            // 如果是本层的最后一个
            if(i==size-1){
                result.add(t.val);
            }
            }

}
return result;

}
}

0 赞同 0 条回复

CV大神普通 2023年7月21日上午8:16

  /**
     * 使用逐层打印二叉树的策略，只是把每一层最后一个添加到列表而已
     * @param root
     * @return
     */
    public List<Integer> rightSideView(TreeNode root) {
        if (root == null) {
            return new ArrayList<>();
        }
        List<Integer> result = new LinkedList<>();
        LinkedList<TreeNode> queue = new LinkedList<>();
        queue.addLast(root);
        while (!queue.isEmpty()) {
            int levelSize = queue.size();
            for (int i = 0; i < levelSize; i++) {
                TreeNode node = queue.pollFirst();
                if (node != null) {
                    if (i == levelSize - 1) {
                        result.add(node.val);
                    }
                    if (node.left != null) {
                        queue.addLast(node.left);
                    }
                    if (node.right != null) {
                        queue.addLast(node.right);
                    }
                }

            }
        }
        return result;
    }

0 赞同 0 条回复

WhyNot 普通 2023年7月19日下午4:32

// 辅助队列节点结构定义
struct QueueNode {
    struct TreeNode* node;
    int level;
};

int* rightSideView(struct TreeNode* root, int* returnSize) {
    if (root == NULL) {
        *returnSize = 0;
        return NULL;
    }

    // 创建结果数组
    int* result = (int*)malloc(sizeof(int));
    int resultSize = 0;

    // 创建队列
    struct QueueNode* queue = (struct QueueNode*)malloc(sizeof(struct QueueNode) * 1000);
    int front = 0, rear = 0;

    // 将根节点入队
    queue[rear].node = root;
    queue[rear].level = 0;
    rear++;

    // 进行BFS遍历
    while (front < rear) {
        struct TreeNode* currNode = queue[front].node;
        int currLevel = queue[front].level;
        front++;

        if (currLevel == resultSize) {  // 当前层级与结果数组的索引对应
            result[resultSize++] = currNode->val;
            // 扩展结果数组
            result = (int*)realloc(result, sizeof(int) * (resultSize + 1));
        } else {
            result[currLevel] = currNode->val;
        }

        if (currNode->left != NULL) {
            queue[rear].node = currNode->left;
            queue[rear].level = currLevel + 1;
            rear++;
        }

        if (currNode->right != NULL) {
            queue[rear].node = currNode->right;
            queue[rear].level = currLevel + 1;
            rear++;
        }
    }

    free(queue);
    *returnSize = resultSize;
    return result;
}

0 赞同 0 条回复

断舍离永久会员 2023年7月14日上午9:28

class Solution {

    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.add(node.left);
                }
                if(node.right != null){
                    queue.add(node.right);
                }
                //关键点：将当前层序遍历的最后一个节点（一定为右节点）放入集合
                if(i == size-1){
                    result.add(node.val);
                }
            }
        }
        return result;
    }
}

0 赞同 0 条回复

彦，，# 普通 2023年7月12日下午11:14

“`cpp
可以深度优先去最后一个
vector rightSideView(TreeNode* root) {
vector res;
if(root ==NULL) return res;
auto flag = root;
queue que;
que.push(root);
while(!que.empty())
{
int size = que.size();
while(size–)
{
TreeNode* node = que.front();
if(0 == size)
{
res.push_back(node->val);
}
que.pop();
if(node->left!=NULL) que.push(node->left);
if(node->right!=NULL) que.push(node->right);
}
}
return res;
}
“`cpp

0 赞同 0 条回复

江畅普通 2023年7月12日下午1:52

// 二叉树的右视图
// 时间复杂度 O(N)
// 空间复杂度 O(N)
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        if (root == nullptr) {
            return {};
        }

        // bfs 层序遍历
        vector<int>      res;
        queue<TreeNode*> que;
        que.push(root);
        while (!que.empty()) {
            int levelSize = que.size();
            for (int i = 0; i < levelSize; ++i) {
                TreeNode* node = que.front();
                que.pop();

                if (node->left != nullptr) {
                    que.push(node->left);
                }
                if (node->right != nullptr) {
                    que.push(node->right);
                }
                // 当前层最后一个节点
                if (i == levelSize - 1) {
                    res.push_back(node->val);
                }
            }
        }
        return res;
    }
};

0 赞同 0 条回复

BOZ 普通 2023年7月12日上午11:28

【思路】BFS遍历二叉树，result即为每一层的最右侧节点组成的列表
【复杂度】时间复杂度O(n)，空间复杂度O(n)

#include <queue>

class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        std::vector<int> result;
        if (!root) return result;

        std::queue<TreeNode*> q;
        q.push(root);

        while(!q.empty()) {
            size_t len = q.size();
            auto n = q.front();
            result.push_back(n->val);
            while(len--) {
                n = q.front(); q.pop();
                if (n->right) q.push(n->right);
                if (n->left) q.push(n->left);
            }
        }
        return result;
    }
};

0 赞同 0 条回复

憨憨永久会员 2023年7月11日下午3:31

用层序遍历二叉树每次将最右边的节点记录

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        if(root==null)return new ArrayList<>();
        List<Integer> ans=new ArrayList<>();
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int a=queue.size();
            TreeNode temp=null;
            for(int i=0;i<a;i++){
                temp=queue.poll();
                if(i==a-1){
                    ans.add(temp.val);
                }
                if(temp.left!=null)queue.offer(temp.left);
                if(temp.right!=null)queue.offer(temp.right);
            }
        }
        return ans;
    }
}

0 赞同 0 条回复

Sexypig. 普通 2023年7月10日下午5:09

这段代码是一个解决二叉树右视图问题的程序。
它通过深度优先搜索（DFS）的方式遍历二叉树，先遍历右子树再遍历左子树。
在遍历过程中，如果当前层还未插入到结果数组res中（说明当前节点为当层最右节点），则将当前节点的值插入到res中。
还可以广度优先（BFS），利用队列进行层序遍历，最后访问的节点即为最右节点
时间复杂度都为O（n）,空间复杂度为O（n）

#include <iostream>
using namespace std;
#include <queue>
#include <vector>

// 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 {
    vector<int> res;

public:
    vector<int> rightSideView(TreeNode *root) {
        if (!root) return {};
        dfs(root, 0);
        return res;
    }
    // 深度优先搜索，中序遍历，先右再左，若当前层还未插入到res中(说明当前节点为当层最右)，则插入
    void dfs(TreeNode *root, int level) {
        if (!root) return;
        if (res.size() == level) {
            res.push_back(root->val);
        }
        dfs(root->right, level + 1);  // 先右
        dfs(root->left, level + 1);   // 再左
    }
};

class Solution2 {
    vector<int> res;

public:
    vector<int> rightSideView(TreeNode *root) {
        if (!root) return {};
        bfs(root);
        return res;
    }
    void bfs(TreeNode *root) {
        if (!root) return;
        queue<TreeNode *> q;
        q.push(root);
        while (!q.empty()) {
            int size = q.size();
            for (int i = 0; i < size; ++i) {
                TreeNode *node = q.front();
                q.pop();
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
                if (i == size - 1) res.push_back(node->val);
            }
        }
    }
};

int main() {
    // 构造测试用例
    TreeNode *root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->right = new TreeNode(5);
    root->right->right = new TreeNode(4);

    // 调用被测试的函数
    // Solution solution;
    // vector<int> result = solution.rightSideView(root);
    Solution2 solution;
    vector<int> result = solution.rightSideView(root);

    // 打印结果
    cout << "Right Side View: ";
    for (int val : result) {
        cout << val << " ";
    }
    cout << endl;

    // 释放内存
    delete root->left->right;
    delete root->right->right;
    delete root->left;
    delete root->right;
    delete root;

    return 0;
}

0 赞同 0 条回复

残月冷骄阳普通 2023年7月9日上午9:48

广度优先思路

复杂度

时间复杂度: $O(n)$
空间复杂度: $O(1)$

Code

/**
 * 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 {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res =     new ArrayList<Integer>();
        if (root == null){
            return res;
        }
      Queue<TreeNode> queue = new LinkedList<>(); 
      queue.add(root);
      while(!queue.isEmpty()){
          int size = queue.size();
          for(int i = 0;i< size;i++){
             TreeNode node = queue.poll();
             if(node.left!=null){
                 queue.add(node.left);
             }
             if(node.right!=null){
                 queue.add(node.right);
             }
             if(i==size-1){
                 res.add(node.val);
             }
          }
      }
      return res;
    }
}

0 赞同 0 条回复

mpweixin用户普通 2023年7月8日上午10:45

java
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        if(root == null) {
            return new ArrayList<>();
        }

        List<Integer> res = new ArrayList<>();
        //进行层序遍历，每一层的最后一位即为右视角所能看到的
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while(!queue.isEmpty()) {
            int k = queue.size();
            TreeNode tmp;
            for(int i = 0; i < k; i++) {
                tmp = queue.poll();
                if(i == k - 1) { //只将每一层的最后一位加入res中
                    res.add(tmp.val);
                }
                if(tmp.left != null) queue.add(tmp.left);
                if(tmp.right != null) queue.add(tmp.right);
            }

        }
        return res;

    }
}

和层序遍历比较相似，每一层的最后一个即为右视角所看到的
时间复杂度为O(n), 遍历了每一个节点
空间复杂度为O(n)

0 赞同 0 条回复

局外人普通 2023年7月5日下午8:20

思路：层序遍历，每一层最后一个加入列表，即为右视图
时间复杂度：O(n) 空间复杂度：O(n)

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root==null)  return list;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while(!queue.isEmpty()){
            int sz = queue.size();

            for(int i=0; i<sz; i++){
                TreeNode cur = queue.poll();
                if(cur.left!=null)  queue.add(cur.left);
                if(cur.right!=null) queue.add(cur.right); 

                if(i==sz-1) list.add(cur.val); 
            }
        }

        return list;
    }
}

0 赞同 0 条回复

名字什么的好麻烦普通 2023年7月4日下午8:16

层序遍历

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

0 赞同 0 条回复

花老爷普通 2023年7月3日下午4:23

bfs
时间：O(n)
空间：O(n)

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Deque<TreeNode> queue = new ArrayDeque<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
                if (i == size - 1) {
                    res.add(node.val);
                }
            }
        }
        return res;
    }
}

dfs
时间：O(n)
空间：O(n)

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        dfs(res, 0, root);
        return res;
    }

    private void dfs(List<Integer> res, int level, TreeNode root) {
        if (root == null) {
            return;
        }
        if (res.size() == level) {
            res.add(root.val);
        }
        dfs(res, level + 1, root.right);
        dfs(res, level + 1, root.left);
    }
}

0 赞同 0 条回复

Dsjh 普通 2023年7月3日下午1:35

MY

层序遍历

class Solution {
public:
    vector<int> ans;
    vector<int> rightSideView(TreeNode* root) {
        if(!root){
            return ans;
        }
        deque<TreeNode*> q;
        q.push_back(root);
        while(!q.empty()){
            int num = q.size();
            while(num--){
                TreeNode* temp = q.front();
                q.pop_front();
                if(num == 0){
                    ans.push_back(temp->val);
                }
                if(temp->left) q.push_back(temp->left);
                if(temp->right) q.push_back(temp->right);
            }
        }
        return ans;
    }
};

0 赞同 0 条回复

Vow the vow。普通 2023年7月3日上午11:16

层次遍历，一层一层的取最右节点。

public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int m = queue.size();
            while(m-- > 0){
                TreeNode node = queue.poll();
                if(m == 0){
                    res.add(node.val);
                }
                if(node.left != null) queue.add(node.left);
                if(node.right != null) queue.add(node.right);
            }
        }
        return res;
    }

0 赞同 0 条回复

Jerry 普通 2023年7月2日下午8:37

 // BFS, 按照 「根结点 -> 右子树 -> 左子树」 的顺序访问
class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
        dfs(root, 0);
        return res;
    }

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

时间复杂度：O(n)
空间复杂度：O(n)

0 赞同 0 条回复

张君雅小妹妹普通 2023年7月2日下午7:27

一开始思维局限在从上往下打印，一直想不出来。后来看了讲解发现是按层遍历，打印每层最后一个，思想跟day8做的剑指 Offer 32 – II. 从上到下打印二叉树类似
时间复杂度：O(N)
空间复杂度：O(N)

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> list = new ArrayList<>();  
        if(root == null) return list;
        // 按层遍历二叉树
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                if(node.right != null){
                    queue.offer(node.right);
                }
                if(i == size - 1){
                    list.add(node.val);
                }
            }
        }

        return list;

    }
}

0 赞同 0 条回复

Ming 普通 2023年7月2日下午2:21

BFS

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        // BFS只存每层最右边的结点
        List<Integer> list = new ArrayList<>();
        if(root == null) return list;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while(!q.isEmpty()) {
            int size = q.size();
            for(int i = 0; i < size; i++) {
                TreeNode cur = q.poll();
                if(cur.left != null) {
                    q.offer(cur.left);
                }
                if(cur.right != null) {
                    q.offer(cur.right);
                }
                if(i == size - 1) {
                    list.add(cur.val);
                }
            }
        }
        return list;
    }
}

0 赞同 0 条回复

怀瑾永久会员 2023年7月2日上午12:54

C++实现

#include <queue>
#include <vector>

std::vector<int> rightSideView(TreeNode* root) {
    std::vector<int> result;
    if (root == NULL) {
        return result;
    }

    std::queue<TreeNode*> q;
    q.push(root);

    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            TreeNode* node = q.front();
            q.pop();

            // 如果是该层的最右侧节点，将其值加入结果中
            if (i == size - 1) {
                result.push_back(node->val);
            }

            // 将下一层的子节点加入队列中
            if (node->left) {
                q.push(node->left);
            }
            if (node->right) {
                q.push(node->right);
            }
        }
    }

    return result;
}

0 赞同 0 条回复

哈哈哈哈开开心心普通 2023年7月2日上午12:52

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rightSideView(self, root: Optional[TreeNode]) -> List[int]:

        res = []

        if not root:
            return res

        q = [root]

        while q:
            level_size = len(q)

            for i in range(level_size):
                node = q.pop(0)
                if i == level_size - 1:
                    res.append(node.val)

                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)

        return res

使用queue实现

0 赞同 0 条回复

yxy 普通 2023年7月2日上午12:26

复杂度O（n）

/**
 * 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> res;
        if(!root) return res;
        queue<TreeNode*> q;
        q.push(root);
        while(q.size())
        {
            int n=q.size();
            for(int i=0;i<n;i++)
            {            
                auto cur = q.front();
                q.pop();
                if(cur->left) q.push(cur->left);
                if(cur->right) q.push(cur->right);
                if(i==n-1)
                    res.push_back(cur->val);
            }
        }
        return res;
    }
};

0 赞同 0 条回复

行动派小彩笔普通 2023年7月1日下午9:06

 // 层次遍历，把每一层最后一个元素添入vector
 // 时间O(n)遍历所有元素，空间O(n) 完全二叉树 可以放下n/2个元素
class Solution {
public:

    vector<int> rightSideView(TreeNode* root) {
        if(!root) return {};
        vector<int> v;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty())
        {
            int i = q.size();
            for(;i>0;--i)
            {
                TreeNode* tmp = q.front();
                q.pop();
                if(i-1==0) 
                    v.push_back(tmp->val);
                if(tmp->left) q.push(tmp->left);
                if(tmp->right) q.push(tmp->right);
            }

        }
        return v;
    }
};

0 赞同 0 条回复

张开怀普通 2023年7月1日下午8:23

class Solution{
public:
       vector<int> rightSideView(TreeNode* root){
              if(!root) return {};

              // 层序遍历，将每层最后一个加入结果数组
              vector<int> ans;
              queue<TreeNode*> que;
              que.push(root);
              while(!que.empty()){
                     int counts = que.size();
                     for(int i=0; i<counts; i++){
                            auto node = que.front();
                            que.pop();

                            if(node->left)  que.push(node->left);
                            if(node->right)  que.push(node->right);
                            if(i == counts-1)  ans.push_back(node->val);
                     }
              }
              return ans;
       }
}

时间复杂度：O(n)

0 赞同 0 条回复

mpweixin用户永久会员 2023年7月1日下午8:02

//思路：层序遍历，每层保留最后一个元素
//时间O(n)  空间O(k) k 为树的宽度
public List<Integer> rightSideView(TreeNode root) {
    if(root == null){
        return new ArrayList();
    }

    Queue<TreeNode> queue = new LinkedList();
    queue.offer(root);
    List<Integer> result = new ArrayList();

    while(!queue.isEmpty()){
        int curSize = queue.size();
        for(int i = 0;i < curSize;i++){
            root = queue.poll();
            if(i == curSize - 1){
                result.add(root.val);
            }
            if(root.left != null){
                queue.offer(root.left);
            }
            if(root.right != null){
                queue.offer(root.right);
            }
        }
    }

    return result;
}

0 赞同 0 条回复

伏月三十普通 2023年7月1日下午4:24

层序遍历：时间复杂度O(n) 空间复杂度O(n)

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        if(root==null){
            return new ArrayList<>();
        }
        List<Integer> list=new ArrayList<>();
        LinkedList<TreeNode> queue=new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode poll=queue.poll();
                if(poll.left!=null){
                    queue.add(poll.left);
                }
                if(poll.right!=null){
                    queue.add(poll.right);
                }

                //判断一下弹出的poll是否是最右边的
                if(i==size-1){
                    list.add(poll.val);
                }
            }
        }
        return list;
    }
}

0 赞同 0 条回复

小吕普通 2023年7月1日下午3:48

c++层序遍历直接解决
vector rightSideView(TreeNode* root) {
vector result;
queue<TreeNode> que;
if(root!=NULL)que.push(root);
while(!que.empty())
{
TreeNode temp;
int len = que.size();
for(int i = 0;i<len;i++)
{
temp= que.front();
que.pop();
if(ilen-1)
{
result.push_back(temp->val);
}
if(temp->left)que.push(temp->left);
if(temp->right)que.push(temp->right);
}
}
return result;
}

0 赞同 0 条回复

Yodl. 普通 2023年7月1日下午2:42

//将二叉树每层按从右到左的顺序进行层次遍历，记录每一层从右开始数的第一个节点
class Solution {
public:
    vector<int> rightSideView(TreeNode* root) {
        vector<int> ans;
        if(root==nullptr)
        {
            return ans;
        }
        queue<TreeNode*> myQue;
        myQue.push(root);
        while(!myQue.empty()){
            int size = myQue.size();
            ans.push_back(myQue.front()->val);
            for(;size--;myQue.pop()){
                TreeNode* node = myQue.front();
                if(node->right)      myQue.push(node->right);
                if(node->left)     myQue.push(node->left);               
            }
        }
        return ans;
    }
};
//时间复杂度O(n)
//空间复杂度O(n)

0 赞同 0 条回复

【二叉树专题】199. 二叉树的右视图

共以下 30 个回答

广度优先思路

复杂度

Code

MY

# 回答此问题取消回复

【二叉树专题】199. 二叉树的右视图

共以下 30 个回答

广度优先思路

复杂度

Code

MY

# 回答此问题 取消回复

# 回答此问题取消回复