《算法通关村—原来如此简单》
《算法通关村—原来如此简单》
理解层序遍历
我们有一个二叉树，我们如何去进行一层一层的遍历呢？
需要我们借用一个数据结构来进行遍历，数据结构就是队列。我们首先把根节点放入队列中，然后从此进行遍历。如何进行遍历？用一个while循环来进行遍历，什么时候队列中为空了什么时候遍历就结束了。
看一下关键代码，我们再接着往下讲：
class TreeNode{
int val;
TreeNode left;
TreeNode right;
public static void bianli(TreeNode root){
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while(!queue.isEmpty()){
int size = queue.size();
for(int i=00;i<size;i++){
TreeNode temp = queue.remove();
if(temp.left != null){
queue.offer(temp.left);
}
if(temp.right != null){
queue.offer(temp.right);
}
}
}
}
}
在一个while循环我们，我们先得到队列此时的大小，其实此时的大小就是这一层的元素个数，我们需要对他们纷纷进行处理，然后把下一层存在的元素加入到队列的尾巴。中间的for循环就是处理一层的元素，for循环 的if就是下一层的元素加入到队列中。
通过这样子的一个流程我们就实现层序遍历。
做题理解
LeetCode102
题目要求：给你一个二叉树，请你返回其按层序遍历得到的节点值。(即逐层地，从左到右访问所有节点)。
示例1：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
解题：
/**
* 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;
* }
* }
*/
import java.util.LinkedList;
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
if(root == null){
return new ArrayList<List<Integer>>();
}
List<List<Integer>> res = new ArrayList<List<Integer>>();
TreeNode t = root;
LinkedList<TreeNode> queue = new LinkedList<>();
queue.add(t);
while(queue.size()> 0){
int size = queue.size();
List<Integer> tmp = new ArrayList<Integer>();
for(int i = 0 ; i< size;i++){
TreeNode temp = queue.remove();
tmp.add(temp.val);
if(temp.left != null){
queue.add(temp.left);
}
if(temp.right!=null){
queue.add(temp.right);
}
}
res.add(tmp);
}
return res;
}
}
二叉树的层序遍历 II
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
示例1：
输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
/**
* 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<List<Integer>> levelOrderBottom(TreeNode root) {
List<List<Integer>> res = new LinkedList<List<Integer>>();
Queue<TreeNode> queue = new LinkedList<TreeNode>();
if(root == null){
return new LinkedList<List<Integer>>();
}
queue.offer(root);
while(!queue.isEmpty()){
int size = queue.size();
List<Integer> temp = new ArrayList<Integer>();
for(int i = 0 ;i<size;i++){
TreeNode t = queue.poll();
temp.add(t.val);
if(t.left !=null){
queue.offer(t.left);
}
if(t.right != null){
queue.offer(t.right);
}
}
res.add(0,temp);
}
return res;
}
}
二叉树的锯齿形层序遍历
给你二叉树的根节点 root ，返回其节点值的 锯齿形层序遍历 。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[20,9],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
/**
* 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<List<Integer>> zigzagLevelOrder(TreeNode root) {
List<List<Integer>> res = new LinkedList<List<Integer>>();
if(root == null){
return new LinkedList<List<Integer>>();
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
Boolean isleft = true;
while(!queue.isEmpty()){
Deque<Integer> temp = new LinkedList<Integer>();
int size = queue.size();
for(int i = 0 ; i< size;i++){
TreeNode t = queue.remove();
if(isleft){
temp.offerLast(t.val);
}else{
temp.offerFirst(t.val);
}
if(t.left != null){
queue.offer(t.left);
}
if(t.right != null){
queue.offer(t.right);
}
}
res.add(new LinkedList<Integer>(temp));
isleft = !isleft;
}
return res;
}
}
429,515,637都是类似的题目哦，一点简单的变化就好了。
找树左下角的值
给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。
示例1：
输入: root = [2,1,3]
输出: 1
示例2：
输入: [1,2,3,4,null,5,6,null,null,7]
输出: 7
一个想法就是进行反转然后到了最后那么队列中最后的一个元素就是我们要找的了。
不好理解我们画一个图理解一下；
在这个二叉树中，我们要找的就是2
要找到最后一层的最左边的元素只需要我们反转，就是每次让节点进入
队列的时候都先让右边的进入，然后最后一个节点就是我们要找的节点。
代码解决：
/**
* 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 findBottomLeftValue(TreeNode root) {
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.add(root);
TreeNode temp = new TreeNode();
while(!queue.isEmpty()){
temp =queue.poll();
if(temp.right!= null){
queue.offer(temp.right);
}
if(temp.left!=null){
queue.offer(temp.left);
}
}
return temp.val;
}
}
点击链接：我正在「编程导航」和朋友们讨论有趣的话题，你⼀起来吧？
也可以加我QQ（2837468248）咨询说明来意！