层序遍历
102. 二叉树的层序遍历
题目链接
https://leetcode.cn/problems/binary-tree-level-order-traversal/description/
题目描述
思路
定义队列去实现，每步在代码注释中均给出了
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
//存放最终结果
List<List<Integer>> list = new ArrayList<>();
if(root==null) return list;
//定义队列进行操作
Queue<TreeNode> deque = new LinkedList<>();
//根节点压入队列
deque.add(root);
//队列不为空就继续操作
while (!deque.isEmpty()){//非空
//存放每一层的结果
List<Integer> list1 = new ArrayList<>();
//保存队列的长度，控制每层的输出数量
int size = deque.size();//1
while (size-->0){//size=1
//弹出元素
TreeNode node = deque.remove();
//存到每一层的结果集中
list1.add(node.val);
if(node.left!=null){
deque.add(node.left);
}
if(node.right!=null){
deque.add(node.right);
}
}
list.add(list1);
}
return list;
}
}
107. 二叉树的层序遍历 II
题目链接
https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/description/
题目描述
思路
在上一题的基础上把结果列表反转即可
class Solution {
public List<List<Integer>> levelOrderBottom(TreeNode root) {
//存放最终结果
List<List<Integer>> list = new ArrayList<>();
if(root==null) return list;
//使用队列控制每层输出数量
Queue<TreeNode> queue = new LinkedList<>();
//把根节点压入
queue.add(root);
while (!queue.isEmpty()){
//定义list存放每层遍历结果
List<Integer> list1 = new ArrayList<>();
int size = queue.size();
while (size-->0){
TreeNode node = queue.remove();
list1.add(node.val);
if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
}
list.add(list1);
}
//反转存放结果的列表，新定义一个列表
List<List<Integer>> result = new ArrayList<>();
for (int i = list.size()-1; i >= 0; i--) {
result.add(list.get(i));
}
return result;
}
}
199.二叉树的右视图
题目链接
https://leetcode.cn/problems/binary-tree-right-side-view/description/
题目描述
思路
层序遍历的时候，判断是否遍历到单层的最后面的元素，如果是，就放进result数组中，随后返回result就可以了。
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.remove();
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;
}
}
637.二叉树的层平均值
题目链接
https://leetcode.cn/problems/average-of-levels-in-binary-tree/description/
题目描述
思路
每一层遍历之后求取平均值
class Solution {
public List<Double> averageOfLevels(TreeNode root) {
List<Double> list = new ArrayList<>();
if(root==null) return list;
//定义队列进行操作
Queue<TreeNode> deque = new LinkedList<>();
//根节点压入队列
deque.add(root);
//队列不为空就继续操作
while (!deque.isEmpty()){//非空
//存放每一层的结果
List<Integer> list1 = new ArrayList<>();
//保存队列的长度，控制每层的输出数量
int size = deque.size();//1
while (size-->0){//size=1
//弹出元素
TreeNode node = deque.remove();
//存到每一层的结果集中
list1.add(node.val);
if(node.left!=null){
deque.add(node.left);
}
if(node.right!=null){
deque.add(node.right);
}
}
double sum = 0;
for (Integer integer : list1) {
sum+=integer;
}
double average = sum/list1.size();
list.add(average);
}
return list;
}
}
429.N叉树的层序遍历
题目链接
https://leetcode.cn/problems/n-ary-tree-level-order-traversal/description/
题目描述
思路
新定义一个树结构，根节点可能包含多个孩子，所以用一个列表去存储孩子节点
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> children;
public Node() {}
public Node(int val) {
this.val = val;
}
public Node(int val, List<Node> children) {
this.val = val;
this.children = children;
}
};
*/
class Solution {
public List<List<Integer>> levelOrder(Node root) {
List<List<Integer>> result = new ArrayList<>();
if(root==null) return result;
Queue<Node> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()){
List<Integer> list = new ArrayList<>();
int size = queue.size();
while (size-->0){
Node node = queue.remove();
list.add(node.val);
List<Node> children = node.children;
if(children==null||children.size()==0){
continue;
}
for (Node child : children) {
queue.add(child);
}
}
result.add(list);
}
return result;
}
}
515.在每个树行中找最大值
题目链接
https://leetcode.cn/problems/find-largest-value-in-each-tree-row/description/
题目描述
思路
遍历完每一层之后求最大值
/**
* 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> largestValues(TreeNode root) {
List<Integer> list = new ArrayList<>();
if(root==null) return list;
//定义队列进行操作
Queue<TreeNode> deque = new LinkedList<>();
//根节点压入队列
deque.add(root);
//队列不为空就继续操作
while (!deque.isEmpty()){//非空
//存放每一层的结果
List<Integer> list1 = new ArrayList<>();
//保存队列的长度，控制每层的输出数量
int size = deque.size();//1
while (size-->0){//size=1
//弹出元素
TreeNode node = deque.remove();
//存到每一层的结果集中
list1.add(node.val);
if(node.left!=null){
deque.add(node.left);
}
if(node.right!=null){
deque.add(node.right);
}
}
Integer max = list1.get(0);
for (Integer integer : list1) {
if(max<integer){
max=integer;
}
}
list.add(max);
}
return list;
}
}
116.填充每个节点的下一个右侧节点指针
题目链接
https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/
题目描述
思路
class Solution {
public Node connect(Node root) {
Queue<Node> tmpQueue = new LinkedList<Node>();
if (root != null) tmpQueue.add(root);
while (tmpQueue.size() != 0){
int size = tmpQueue.size();
Node cur = tmpQueue.poll();
if (cur.left != null) tmpQueue.add(cur.left);
if (cur.right != null) tmpQueue.add(cur.right);
for (int index = 1; index < size; index++){
Node next = tmpQueue.poll();
if (next.left != null) tmpQueue.add(next.left);
if (next.right != null) tmpQueue.add(next.right);
cur.next = next;
cur = next;
}
}
return root;
}
}
117.填充每个节点的下一个右侧节点指针II
题目链接
https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/
题目描述
思路
// 二叉树之层次遍历
class Solution {
public Node connect(Node root) {
Queue<Node> queue = new LinkedList<>();
if (root != null) {
queue.add(root);
}
while (!queue.isEmpty()) {
int size = queue.size();
Node node = null;
Node nodePre = null;
for (int i = 0; i < size; i++) {
if (i == 0) {
nodePre = queue.poll(); // 取出本层头一个节点
node = nodePre;
} else {
node = queue.poll();
nodePre.next = node; // 本层前一个节点 next 指向当前节点
nodePre = nodePre.next;
}
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
}
nodePre.next = null; // 本层最后一个节点 next 指向 null
}
return root;
}
}
104.二叉树的最大深度
题目链接
https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/
题目描述
思路
每遍历一层，深度就加一，所以最大深度就是二叉树的层数
/**
* 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 int maxDepth(TreeNode root) {
if(root==null) return 0;
Queue<TreeNode> queue = new LinkedList<>();
int depthest = 0;
if(root!=null) queue.add(root);
while (!queue.isEmpty()){
int size = queue.size();
while (size-->0){
TreeNode node = queue.remove();
if(node.left!=null) queue.add(node.left);
if(node.right!=null) queue.add(node.right);
}
depthest++;
}
return depthest;
}
}
111.二叉树的最小深度
题目链接
https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/
题目描述
思路
只要遇到左右孩子均为空，就返回深度，即为最小深度
/**
* 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 int minDepth(TreeNode root) {
if(root==null) return 0;
Queue<TreeNode> queue = new LinkedList<>();
int depth = 0;
queue.add(root);
while (!queue.isEmpty()){
depth++;
int size = queue.size();
for (int i = 0; i < size; i++) {
TreeNode cur = queue.remove();
if(cur.left==null&&cur.right==null) return depth;
if(cur.left!=null) queue.add(cur.left);
if(cur.right!=null) queue.add(cur.right);
}
}
return depth;
}
}
226.反转二叉树
题目链接
https://leetcode.cn/problems/invert-binary-tree/description/
题目描述
思路
使用前序或者后序遍历，递归方法（中序不行）
public static TreeNode invertTree(TreeNode root) {
//前序
// if(root==null) return root;
// swap(root);
// invertTree(root.left);
// invertTree(root.right);
// return root;
//后序
if(root==null) return root;
invertTree(root.left);
invertTree(root.right);
swap(root);
return root;
}
public static void swap(TreeNode node){
TreeNode temp = node.left;
node.left = node.right;
node.right = temp;
}
101.对称二叉树
题目链接
https://leetcode.cn/problems/symmetric-tree/description/
题目描述
思路
/**
* 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 boolean isSymmetric(TreeNode root) {
boolean compare = compare(root.left, root.right);
return compare;
}
public boolean compare(TreeNode left,TreeNode right){
if(left==null&&right==null) return true;
else if(left!=null&&right==null) return false;
else if(left==null&&right!=null) return false;
else if(left.val!=right.val) return false;
boolean compareOutside = compare(left.left,right.right);
boolean compareInside = compare(left.right,right.left);
return compareOutside&&compareInside;
}
}
446
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
