leetcode 力扣 199 二叉树的右视图题解 算法题.docx
《leetcode 力扣 199 二叉树的右视图题解 算法题.docx》由会员分享，可在线阅读，更多相关《leetcode 力扣 199 二叉树的右视图题解 算法题.docx（17页珍藏版）》请在冰豆网上搜索。
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
语言:
Python
classSolution:
defrightSideView（self,root:
TreeNode）->List[int]:
rightmost_value_at_depth=dict（）#深度为索引，存放节点的值
max_depth=-1
stack=[（root,0）]
whilestack:
node,depth=stack.pop（）
ifnodeisnotNone:
#维护二叉树的最大深度
max_depth=max（max_depth,depth）
#如果不存在对应深度的节点我们才插入
rightmost_value_at_depth.setdefault（depth,node.val）
stack.append（（node.left,depth+1））
stack.append（（node.right,depth+1））
return[rightmost_value_at_depth[depth]fordepthinrange（max_depth+1）]
语言:
Python
classSolution:
defrightSideView（self,root:
TreeNode）->List[int]:
rightmost_value_at_depth=dict（）#深度为索引，存放节点的值
max_depth=-1
queue=deque（[（root,0）]）
whilequeue:
node,depth=queue.popleft（）
ifnodeisnotNone:
#维护二叉树的最大深度
max_depth=max（max_depth,depth）
#由于每一层最后一个访问到的节点才是我们要的答案，因此不断更新对应深度的信息即可
rightmost_value_at_depth[depth]=node.val
queue.append（（node.left,depth+1））
queue.append（（node.right,depth+1））
return[rightmost_value_at_depth[depth]fordepthinrange（max_depth+1）]
语言:
Java
classSolution{
publicListrightSideView（TreeNoderoot）{
MaprightmostValueAtDepth=newHashMap（）;
intmax_depth=-1;
DequenodeStack=newArrayDeque（）;
DequedepthStack=newArrayDeque（）;
nodeStack.push（root）;
depthStack.push（0）;
while（!
nodeStack.isEmpty（））{
TreeNodenode=nodeStack.pop（）;
intdepth=depthStack.pop（）;
if（node!
=null）{
//维护二叉树的最大深度
max_depth=Math.max（max_depth,depth）;
//如果不存在对应深度的节点我们才插入
if（!
rightmostValueAtDepth.containsKey（depth））{
rightmostValueAtDepth.put（depth,node.val）;
}
nodeStack.push（node.left）;
nodeStack.push（node.right）;
depthStack.push（depth+1）;
depthStack.push（depth+1）;
}
}
ListrightView=newArrayList（）;
for（intdepth=0;depth<=max_depth;depth++）{
rightView.add（rightmostValueAtDepth.get（depth））;
}
returnrightView;
}
}
语言:
Java
classSolution{
publicListrightSideView（TreeNoderoot）{
MaprightmostValueAtDepth=newHashMap（）;
intmax_depth=-1;
QueuenodeQueue=newArrayDeque（）;
QueuedepthQueue=newArrayDeque（）;
nodeQueue.add（root）;
depthQueue.add（0）;
while（!
nodeQueue.isEmpty（））{
TreeNodenode=nodeQueue.remove（）;
intdepth=depthQueue.remove（）;
if（node!
=null）{
//维护二叉树的最大深度
max_depth=Math.max（max_depth,depth）;
//由于每一层最后一个访问到的节点才是我们要的答案，因此不断更新对应深度的信息即可
rightmostValueAtDepth.put（depth,node.val）;
nodeQueue.add（node.left）;
nodeQueue.add（node.right）;
depthQueue.add（depth+1）;
depthQueue.add（depth+1）;
}
}
ListrightView=newArrayList（）;
for（intdepth=0;depth<=max_depth;depth++）{
rightView.add（rightmostValueAtDepth.get（depth））;
}
returnrightView;
}
}
语言:
Java
classSolution{
publicListrightSideView（TreeNoderoot）{
Listres=newArrayList<>（）;
if（root==null）{
returnres;
}
Queuequeue=newLinkedList<>（）;
queue.offer（root）;
while（!
queue.isEmpty（））{
intsize=queue.size（）;
for（inti=0;i TreeNodenode=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）;
}
}
}
returnres;
}
}
语言:
C++
classSolution{
public:
vectorrightSideView（TreeNode*root）{
unordered_maprightmostValueAtDepth;
intmax_depth=-1;
stacknodeStack;
stackdepthStack;
nodeStack.push（root）;
depthStack.push（0）;
while（!
nodeStack.empty（））{
TreeNode*node=nodeStack.top（）;nodeStack.pop（）;
intdepth=depthStack.top（）;depthStack.pop（）;
if（node!
=NULL）{
//维护二叉树的最大深度
max_depth=max（max_depth,depth）;
//如果不存在对应深度的节点我们才插入
if（rightmostValueAtDepth.find（depth）==rightmostValueAtDepth.end（））{
rightmostValueAtDepth[depth]=node->val;
}
nodeStack.push（node->left）;
nodeStack.push（node->right）;
depthStack.push（depth+1）;
depthStack.push（depth+1）;
}
}
vectorrightView;
for（intdepth=0;depth<=max_depth;++depth）{
rightView.push_back（rightmostValueAtDepth[depth]）;
}
returnrightView;
}
};
语言:
C++
classSolution{
public:
vectorrightSideView（TreeNode*root）{
unordered_maprightmostValueAtDepth;
intmax_depth=-1;
queuenodeQueue;
queuedepthQueue;
nodeQueue.push（root）;
depthQueue.push（0）;
while（!
nodeQueue.empty（））{
TreeNode*node=nodeQueue.front（）;nodeQueue.pop（）;
intdepth=depthQueue.front（）;depthQueue.pop（）;
if（node!
=NULL）{
//维护二叉树的最大深度
max_depth=max（max_depth,depth）;
//由于每一层最后一个访问到的节点才是我们要的答案，因此不断更新对应深度的信息即可
rightmostValueAtDepth[depth]=node->val;
nodeQueue.push（node->left）;
nodeQueue.push（node->right）;
depthQueue.push（depth+1）;
depthQueue.push（depth+1）;
}
}
vectorrightView;
for（intdepth=0;depth<=max_depth;++depth）{
rightView.push_back（rightmostValueAtDepth[depth]）;
}
returnrightView;
}
};
语言:
CPP
classSolution{
public:
vector>levelOrder（TreeNode*root）{
queueque;
if（root!
=NULL）que.push（root）;
vector>result;
while（!
que.empty（））{
intsize=que.size（）;
vectorvec;
//这里一定要使用固定大小size，不要使用que.size（），因为que.size是不断变化的
for（inti=0;iTreeNode*node=que.front（）;
que.pop（）;
vec.push_back（node->val）;
if（node->left）que.push（node->left）;
if（node->right）que.push（node->right）;
}
result.push_back（vec）;
}
returnresult;
}
};
语言:
CPP
classSolution{
public:
vector>levelOrderBottom（TreeNode*root）{
queueque;
if（root!
=NULL）que.push（root）;
vector>result;
while（!
que.empty（））{
intsize=que.size（）;
vectorvec;
for（inti=0;iTreeNode*node=que.front（）;
que.pop（）;
vec.push_back（node->val）;
if（node->left）que.push（node->left）;
if（node->right）que.push（node->right）;
}
result.push_back（vec）;
}
reverse（result.begin（）,result.end（））;//在这里反转一下数组即可
returnresult;
}
};
语言:
CPP
classSolution{
public:
vectorrightSideView（TreeNode*root）{
queueque;
if（root!
=NULL）que.push（root）;
vectorresult;
while（!
que.empty（））{
intsize=que.size（）;
for（inti=0;iTreeNode*node=que.front（）;
que.pop（）;
if（i==（size-1））result.push_back（node->val）;//将每一层的最后元素放入result数组中
if（node->left）que.push（node->left）;
if（node->right）que.push（node->right）;
}
}
returnresult;
}
};
语言:
go
/**
102.二叉树的层序遍历
*/
funclevelOrder（root*TreeNode）[][]int{
res:
=[][]int{}
ifroot==nil{//防止为空
returnres
}
queue:
=list.New（）
queue.PushBack（root）
vartmpArr[]int
forqueue.Len（）>0{
length:
=queue.Len（）//保存当前层的长度，然后处理当前层（十分重要，防止添加下层元素影响判断层中元素的个数）
fori:
=0;inode:
=queue.Remove（queue.Front（））.（*TreeNode）//出队列
ifnode.Left!
=nil{
queue.PushBack（node.Left）
}
ifnode.Right!
=nil{
queue.PushBack（node.Right）
}
tmpArr=append（tmpArr,node.Val）//将值加入本层切片中
}
res=append（res,tmpArr）//放入结果集
tmpArr=[]int{}//清空层的数据
}
returnres
}
语言:
go
funcrightSideView（root*TreeNode）[]int{
que:
=make（[]*TreeNode,0）
ans:
=make（[]int,0）
ifroot==nil{
returnans
}
que=append（que,root）
forlen（que）>0{
length:
=len（que）
fori:
=0;it:
=que[0]
que=que[1:
]
ift.Left!
=nil{
que=append（que,t.Left）
}
ift.Right!
=nil{
que=append（que,t.Right）
}
ifi==length-1{
ans=append（ans,t.Val）
}
}
}
returnans
}
语言:
go
funcrightSideView（root*TreeNode）[]int{
ans:
=make（[]int,0）
ifroot==nil{
returnans
}
que:
=list.New（）
que.PushBack（root）
forque.Len（）>0{
length:
=que.Len（）
fori:
=0;it:
=que.Front（）.Value.（*TreeNode）
que.Remove（que.Front（））
ift.Left!
=nil{
que.PushBack（t.Left）
}
ift.Right!
=nil{
que.PushBack（t.Right）
}
ifi==length-1{
ans=append（ans,t.Val）
}
}
}
returnans
}
语言:
javascript
varlevelOrder=function（root）{
//二叉树的层序遍历
letres=[],queue=[];
queue.push（root）;
if（root===null）{
returnres;
}
while（queue.length!
==0）{
//记录当前层级节点数
letlength=queue.length;
//存放每一层的节点
letcurLevel=[];
for（leti=0;iletnode=queue.shift（）;
curLevel.push（node.val）;
//存放当前层下一层的节点
node.left&&queue.push（node.left）;
node.right&&queue.push（node.right）;
}
//把每一层的结果放到结果数组
res.push（curLevel）;
}
returnres;
};
语言:
javascript
varlevelOrderBottom=function（root）{
letres=[],queue=[];
queue.push（root）;
while（queue.length&&root!
==null）{
//存放当前层级节点数组
letcurLevel=[];
//计算当前层级节点数量
letlength=queue.length;
while（length--）{
letnode=queue.shift（）;
//把当前层节点存入curLevel数组
curLevel.push（node.val）;
//把下一层级的左右节点存入queue队列
node.left&&queue.push（node.left）;
node.right&&queue.push（node.right）;
}
res.push（curLevel）;
}
returnres.reverse（）;
};
语言:
javascript
varrightSideView=function（root）{
//二叉树右视图只需要把每一层最后一个节点存储到res数组
letres=[],queue=[];
queue.push
升级会员 