一、题目
给定一棵二叉树,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。
示例:
输入: [1,2,3,null,5,null,4]
输出: [1, 3, 4]
解释:
1 <---
/ \
2 3 <---
\ \
5 4 <---
二、解决
1、BFS
思路: 对BFS模板略加修改即可。
代码:
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 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;
}
}
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
O(n)
O(n)
2、DFS
思路: 对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);
}
}
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
O(n)
O(n)
三、NC136
思路: 先重建二叉树,再返回遍历右视图结果。
代码:
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
* 求二叉树的右视图
* @param xianxu int整型一维数组 先序遍历
* @param zhongxu int整型一维数组 中序遍历
* @return int整型一维数组
*/
int[] preOrder;
HashMap<Integer, Integer> dic = new HashMap<>();
public int[] solve (int[] xianxu, int[] zhongxu) {
preOrder = xianxu;
for (int i = 0; i < zhongxu.length; i++) {
dic.put(zhongxu[i], i);
}
TreeNode root = buildTree(0, 0, zhongxu.length - 1);
return rightSideView(root);
}
public int[] rightSideView(TreeNode root) {
Queue<TreeNode> q = new LinkedList<>();
if (root != null) q.add(root);
List<Integer> tmp = new ArrayList<>();
while (!q.isEmpty()) {
for (int i = q.size(); i > 0; i--) {
TreeNode node = q.poll();
if (node.left != null) q.add(node.left);
if (node.right != null) q.add(node.right);
if (i == 1) tmp.add(node.val);
}
}
// return tmp;
int[] res = new int[tmp.size()];
for (int i = 0; i < res.length; i++) {
res[i] = tmp.get(i);
}
return res;
}
public TreeNode buildTree(int preRoot, int inLeft, int inRight) {
if (inLeft > inRight) return null;
TreeNode root = new TreeNode(preOrder[preRoot]);
int inRoot = dic.get(preOrder[preRoot]);
root.left = buildTree(preRoot+1, inLeft, inRoot-1);
root.right = buildTree(preRoot+inRoot-inLeft+1, inRoot+1, inRight);
return root;
}
}
时间复杂度:
O
(
n
)
O(n)
O(n)
空间复杂度:
O
(
n
)
O(n)
O(n)
四、参考
1、简单BFS/DFS, 🤷♀️必须秒懂!
2、Reverse Level Order Traversal, java
3、Share my Java iterative solution, based on level order traversal
4、My simple accepted solution(JAVA)