打卡第15天
102.二叉树的层序遍历
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
需要一个队列完成操作，值得注意的是这道题要分层输出，所以要设置一个size记录一层的大小，处理完size大小之后的再继续操作下一层。
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
// 存储结果的List
List<List<Integer>> resList = new ArrayList<List<Integer>>();
levelOrderFunc(root,resList);
return resList;
}
public void levelOrderFunc(TreeNode root,List<List<Integer>> resList){
if(root==null){
return ;
}
Deque<TreeNode> deque = new LinkedList<TreeNode>();
deque.offer(root);
while(!deque.isEmpty()){
// 这一步是为了分层的，处理完size大小的内容即为一层
int size = deque.size();
List<Integer> itemList = new ArrayList<Integer>();
while(size>0){
TreeNode tempNode = deque.poll();
itemList.add(tempNode.val);
// 把当前节点的左右子节点放入队列
if(tempNode.left!=null)
deque.offer(tempNode.left);
if(tempNode.right!=null)
deque.offer(tempNode.right);
size--;
}
resList.add(itemList);
}
}
}
107.二叉树的层序遍历II
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
继续按上一题的做法，最后反转List即可。
class Solution {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
// 存储结果的List
List<List<Integer>> resList = new ArrayList<List<Integer>>();
levelOrderFunc(root,resList);
return resList;
}
public void levelOrderFunc(TreeNode root,List<List<Integer>> resList){
if(root==null){
return ;
}
List<List<Integer>> result = new ArrayList<>();
Deque<TreeNode> deque = new LinkedList<TreeNode>();
deque.offer(root);
while(!deque.isEmpty()){
// 这一步是为了分层的，处理完size大小的内容即为一层
int size = deque.size();
List<Integer> itemList = new ArrayList<Integer>();
while(size>0){
TreeNode tempNode = deque.poll();
itemList.add(tempNode.val);
// 把当前节点的左右子节点放入队列
if(tempNode.left!=null)
deque.offer(tempNode.left);
if(tempNode.right!=null)
deque.offer(tempNode.right);
size--;
}
result.add(itemList);
}
for (int i = result.size() - 1; i >= 0; i-- ) {
resList.add(result.get(i));
}
}
}
199.二叉树的右视图
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
这道题还是层序遍历，分层后的size==1时就是要求的那个值，加入resultList即可，java代码如下。
class Solution {
public List<Integer> rightSideView(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
if(root==null){
return result;
}
levelOrderFunc(root,result);
return result;
}
public void levelOrderFunc(TreeNode root,List<Integer> result){
if(root==null){
return ;
}
Deque<TreeNode> deque = new LinkedList<TreeNode>();
deque.offer(root);
while(!deque.isEmpty()){
// 这一步是为了分层的，处理完size大小的内容即为一层
// 在这一题时，size=1时存储值
int size = deque.size();
while(size>0){
TreeNode tempNode = deque.poll();
// 把当前节点的左右子节点放入队列
if(tempNode.left!=null){
deque.offer(tempNode.left);
}
if(tempNode.right!=null){
deque.offer(tempNode.right);
}
if(size==1){
result.add(tempNode.val);
}
size--;
}
}
}
}
637.二叉树的层平均值
求出来每一层的平均值即可
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
List<Double> result = new ArrayList<Double>();
if(root==null){
return result;
}
levelOrderFunc(root,result);
return result;
}
public void levelOrderFunc(TreeNode root,List<Double> result){
if(root==null){
return ;
}
Deque<TreeNode> deque = new LinkedList<TreeNode>();
deque.offer(root);
while(!deque.isEmpty()){
// 这一步是为了分层的，处理完size大小的内容即为一层
int size = deque.size();
List<Integer> itemList = new ArrayList<Integer>();
while(size>0){
TreeNode tempNode = deque.poll();
itemList.add(tempNode.val);
// 把当前节点的左右子节点放入队列
if(tempNode.left!=null)
deque.offer(tempNode.left);
if(tempNode.right!=null)
deque.offer(tempNode.right);
size--;
}
Double sum = 0D;
int ListSize = itemList.size();
for(int i=0;i<ListSize;i++){
sum+=itemList.get(i);
}
result.add(sum/ListSize);
}
}
}
429.N 叉树的层序遍历、
需要new一个List 然后用增强for循环遍历，不等于null的加进队列即可
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> result = new ArrayList<List<Integer>>();;
if(root==null){
return result;
}
levelOrderFunc(root,result);
return result;
}
public void levelOrderFunc(Node root,List<List<Integer>> resList){
if(root==null){
return ;
}
Deque<Node> deque = new LinkedList<Node>();
deque.offer(root);
while(!deque.isEmpty()){
// 这一步是为了分层的，处理完size大小的内容即为一层
int size = deque.size();
List<Integer> itemList = new ArrayList<Integer>();
for (int i = 0; i < size; i++) {
Node poll = deque.pollFirst();
itemList.add(poll.val);
// 把子节点加入队列中
List<Node> children = poll.children;
if (children == null || children.size() == 0) {
continue;
}
for (Node child : children) {
if (child != null) {
deque.offerLast(child);
}
}
}
resList.add(itemList);
}
}
}
515.在每个树行中找最大值
层序遍历，处理每层得到的数组得到最大值即可
class Solution {
public List<Integer> largestValues(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
if(root==null){
return result;
}
levelOrderFunc(root,result);
return result;
}
public void levelOrderFunc(TreeNode root,List<Integer> result){
if(root==null){
return ;
}
Deque<TreeNode> deque = new LinkedList<TreeNode>();
deque.offer(root);
while(!deque.isEmpty()){
// 这一步是为了分层的，处理完size大小的内容即为一层
int size = deque.size();
List<Integer> itemList = new ArrayList<Integer>();
while(size>0){
TreeNode tempNode = deque.poll();
itemList.add(tempNode.val);
// 把当前节点的左右子节点放入队列
if(tempNode.left!=null){
deque.offer(tempNode.left);
}
if(tempNode.right!=null){
deque.offer(tempNode.right);
}
size--;
}
result.add(Collections.max(itemList));
}
}
}
116.填充每个节点的下一个右侧节点指针
需要对每一层的第一个节点进行特殊处理，后续的就正常处理即可
class Solution {
public Node connect(Node root) {
levelOrderFunc(root);
return root;
}
public void levelOrderFunc(Node root){
if(root==null){
return;
}
Deque<Node> deque = new LinkedList<Node>();
deque.offer(root);
while(!deque.isEmpty()){
// 这一步是为了分层的，处理完size大小的内容即为一层
int size = deque.size();
Node cur = deque.poll();
// 先把每一层的第一个节点的左右子节点加入队列
if (cur.left != null)
deque.add(cur.left);
if (cur.right != null)
deque.add(cur.right);
// 依次处理后续的节点，相当于头节点单独处理了
for (int index = 1; index < size; index++){
Node next = deque.poll();
if (next.left != null)
deque.add(next.left);
if (next.right != null)
deque.add(next.right);
cur.next = next;
cur = next;
}
}
}
}
117.填充每个节点的下一个右侧节点指针 II
处理方法和上一题类似，也是先处理每一行第一个节点，后续节点继续处理，使用了一个NodePre一个Node，把NodePre指向Node，最后一个节点指向null即可。
class Solution {
public Node connect(Node root) {
Deque<Node> deque = new LinkedList<>();
if (root != null) {
deque.add(root);
}
while (!deque.isEmpty()) {
int size = deque.size();
// 取出本层头一个节点
Node nodePre = deque.poll();
Node node = nodePre;
if (node.left != null) {
deque.add(node.left);
}
if (node.right != null) {
deque.add(node.right);
}
for (int i = 1; i < size; i++) {
node = deque.poll();
nodePre.next = node; // 本层前一个节点 next 指向当前节点
nodePre = nodePre.next;
if (node.left != null) {
deque.add(node.left);
}
if (node.right != null) {
deque.add(node.right);
}
}
nodePre.next = null; // 本层最后一个节点 next 指向 null
}
return root;
}
}
104.二叉树的最大深度
class Solution {
public int maxDepth(TreeNode root) {
if (root == null)
return 0;
Deque<TreeNode> deque = new LinkedList<>();
deque.offer(root);
int depth = 0;
while (!deque.isEmpty())
{
int size = deque.size();
while (size > 0)
{
TreeNode cur = deque.poll();
if (cur.left != null)
deque.offer(cur.left);
if (cur.right != null)
deque.offer(cur.right);
size--;
}
depth++;
}
return depth;
}
}
111.二叉树的最小深度
这个要先让depth++
class Solution {
public int minDepth(TreeNode root) {
if (root == null)
return 0;
Deque<TreeNode> deque = new LinkedList<>();
deque.offer(root);
int depth = 0;
while (!deque.isEmpty())
{
int size = deque.size();
depth++;
while (size > 0)
{
TreeNode cur = deque.poll();
if (cur.left != null)
deque.offer(cur.left);
if (cur.right != null)
deque.offer(cur.right);
if(cur.left == null&&cur.right == null){
return depth;
}
size--;
}
}
return depth;
}
}
226.翻转二叉树
用递归做，前序和后序遍历都可以
class Solution {
public TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
invertTree(root.left);
invertTree(root.right);
swapChildren(root);
return root;
}
private void swapChildren(TreeNode root) {
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
}
}
101.对称二叉树
class Solution {
public boolean isSymmetric(TreeNode root) {
return compare(root.left,root.right);
}
private boolean compare(TreeNode left, TreeNode right) {
if (left == null && right != null) {
return false;
}
if (left != null && right == null) {
return false;
}
if (left == null && right == null) {
return true;
}
if (left.val != right.val) {
return false;
}
// 比较外侧
boolean compareOutside = compare(left.left, right.right);
// 比较内侧
boolean compareInside = compare(left.right, right.left);
return compareOutside && compareInside;
}
}
扫一扫
220
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
