代码随想录刷题笔记Day14-- 二叉树层序遍历 翻转二叉树 对称二叉树
代码随想录刷题笔记Day14-- 二叉树理论基础 层序遍历 翻转二叉树 对称二叉树
LeetCode 102. 二叉树的层序遍历
题目描述：
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例 1:
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
解题思路
使用队列解决这个问题
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var levelOrder = function(root) {
let res = [], queue = [];
queue.push(root);
if(root === null) {
return res;
}
while(queue.length!==0)
{
let length=queue.length;
let curLevel=[];
for(let i=0;i<length;i++)
{
let node=queue.shift();
curLevel.push(node.val);
if(node.left)
queue.push(node.left);
if(node.right)
queue.push(node.right);
}
res.push(curLevel);
}
return res;
};
LeetCode 107. 二叉树的层序遍历 II
题目描述：
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
示例 1:
输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]
解题思路
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var levelOrder = function(root) {
let res = [], queue = [];
queue.push(root);
if(root === null) {
return res;
}
while(queue.length!==0)
{
let length=queue.length;
let curLevel=[];
for(let i=0;i<length;i++)
{
let node=queue.shift();
curLevel.push(node.val);
if(node.left)
queue.push(node.left);
if(node.right)
queue.push(node.right);
}
res.push(curLevel);
}
return res.reverse();
};
LeetCode 199. 二叉树的右视图
题目描述：
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
示例 1:
输入：root = [1,null,2,3]
输出：[1,3,2]
解题思路
层序遍历每一层的最后一个值
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var rightSideView = function(root) {
let res = [], queue = [];
queue.push(root);
if(root === null) {
return res;
}
while(queue.length!==0)
{
let length=queue.length;
let curLevel=[];
for(let i=0;i<length;i++)
{
let node=queue.shift();
curLevel.push(node.val);
if(node.left)
queue.push(node.left);
if(node.right)
queue.push(node.right);
}
let length_1=curLevel.length;
res.push(curLevel[length_1-1]);
}
return res;
};
LeetCode 637. 二叉树的层平均值
题目描述：
给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。
示例 1:
输入：root = [3,9,20,null,null,15,7]
输出：[3.00000,14.50000,11.00000]
解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
因此返回 [3, 14.5, 11] 。
解题思路
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var averageOfLevels = function(root) {
let res = [], queue = [];
queue.push(root);
if(root === null) {
return res;
}
while(queue.length!==0)
{
let length=queue.length;
let curLevel=[];
for(let i=0;i<length;i++)
{
let node=queue.shift();
curLevel.push(node.val);
if(node.left)
queue.push(node.left);
if(node.right)
queue.push(node.right);
}
let length_1=curLevel.length;
let sum=0;
for(let i of curLevel)
sum+=i;
res.push(sum/length_1);
}
return res;
};
LeetCode 429. N 叉树的层序遍历
题目描述：
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
示例 1:
输入：root = [1,null,3,2,4,null,5,6]
输出：[[1],[3,2,4],[5,6]]
解题思路
解法：
写法
/**
* // Definition for a Node.
* function Node(val,children) {
* this.val = val;
* this.children = children;
* };
*/
/**
* @param {Node|null} root
* @return {number[][]}
*/
var levelOrder = function(root) {
let res = [], queue = [];
queue.push(root);
if(root === null) {
return res;
}
while(queue.length!==0)
{
let length=queue.length;
let curLevel=[];
for(let i=0;i<length;i++)
{
let node=queue.shift();
curLevel.push(node.val);
for(child of node.children)
queue.push(child);
}
res.push(curLevel);
}
return res;
};
LeetCode 515. 在每个树行中找最大值
题目描述：
给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例 1:
输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]
解题思路
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var largestValues = function(root) {
let res=[],queue=[];
queue.push(root);
if(root===null){
return res;
}
while(queue.length!=0)
{
let length=queue.length;
let max;
for(let i=0;i<length;i++)
{ let node=queue.shift();
max=max>node.val?max:node.val;
if(node.left!=null)
queue.push(node.left);
if(node.right!=null)
queue.push(node.right);
}
res.push(max);
}
return res;
};
LeetCode 116. 填充每个节点的下一个右侧节点指针
题目描述：
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
示例 1:
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
解题思路
解法：
写法
/**
* // Definition for a Node.
* function Node(val, left, right, next) {
* this.val = val === undefined ? null : val;
* this.left = left === undefined ? null : left;
* this.right = right === undefined ? null : right;
* this.next = next === undefined ? null : next;
* };
*/
/**
* @param {Node} root
* @return {Node}
*/
var connect = function(root) {
if (root === null) return root;
let queue = [root];
while (queue.length) {
let n = queue.length;
for (let i = 0; i < n; i++) {
let node = queue.shift();
if (i < n-1) {
node.next = queue[0];
}
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
}
return root;
};
LeetCode 117. 填充每个节点的下一个右侧节点指针 II
题目描述：
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。
进阶：
- 你只能使用常量级额外空间。
- 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
示例 1:
输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
解题思路
解法：
写法
/**
* // Definition for a Node.
* function Node(val, left, right, next) {
* this.val = val === undefined ? null : val;
* this.left = left === undefined ? null : left;
* this.right = right === undefined ? null : right;
* this.next = next === undefined ? null : next;
* };
*/
/**
* @param {Node} root
* @return {Node}
*/
var connect = function(root) {
if (root === null) return root;
let queue = [root];
while (queue.length) {
let n = queue.length;
for (let i = 0; i < n; i++) {
let node = queue.shift();
if (i < n-1) {
node.next = queue[0];
}
node.left && queue.push(node.left);
node.right && queue.push(node.right);
}
}
return root;
};
LeetCode 104. 二叉树的最大深度
题目描述：
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]，
返回它的最大深度 3 。
解题思路
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number}
*/
var maxDepth = function(root) {
let count=0,queue=[];
queue.push(root);
if(root===null){
return 0;
}
while(queue.length!=0)
{
let length=queue.length;
for(let i=0;i<length;i++)
{ let node=queue.shift();
if(node.left!=null)
queue.push(node.left);
if(node.right!=null)
queue.push(node.right);
}
count++;
}
return count;
};
LeetCode 111. 二叉树的最小深度
题目描述：
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
**说明：**叶子节点是指没有子节点的节点。
示例 1:
输入：root = [3,9,20,null,null,15,7]
输出：2
解题思路
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number}
*/
var minDepth = function (root) {
let depth = 0, queue = [];
queue.push(root);
if (root === null) {
return 0;
}
while (queue.length != 0) {
depth++;
let length = queue.length;
for (let i = 0; i < length; i++) {
let node = queue.shift();
if (node.left != null)
queue.push(node.left);
if (node.right != null)
queue.push(node.right);
if (node.left == null && node.right == null)
return depth;
}
}
return depth;
};
LeetCode 226. 翻转二叉树
题目描述：
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例 1:
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
解题思路
关键在于遍历顺序，前中后序应该选哪一种遍历顺序？
遍历的过程中去翻转每一个节点的左右孩子就可以达到整体翻转的效果。
注意只要把每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果
这道题目使用前序遍历和后序遍历都可以，唯独中序遍历不方便，因为中序遍历会把某些节点的左右孩子翻转了两次！
那么层序遍历可以不可以呢？依然可以的！只要把每一个节点的左右孩子翻转一下的遍历方式都是可以的！
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
//前序遍历反转二叉树
var invertTree = function (root) {
function dfs(root){
if (!root) {
return ;
}
let node=root.left;
root.left=root.right;
root.right=node;
dfs(root.left);
dfs(root.right);
}
dfs(root);
return root;
};
//层序遍历反转二叉树
var invertTree = function (root) {
if (root === null) return root;
let queue = [root];
while (queue.length) {
let n = queue.length;
for (let i = 0; i < n; i++) {
let node = queue.shift();
let temp=node.left;
node.left=node.right;
node.right=temp;
if(node.left!=null)
queue.push(node.left);
if(node.right!=null)
queue.push(node.right);
}
}
return root;
};
LeetCode 101. 对称二叉树
题目描述：
给你一个二叉树的根节点 root ， 检查它是否轴对称。
示例 1:
输入：root = [1,2,2,3,4,4,3]
输出：true
解题思路
解法：
写法
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {number[]}
*/
var isSymmetric = function(root) {
// 使用递归遍历左右子树 递归三部曲
// 1. 确定递归的参数 root.left root.right和返回值true false
const compareNode = function(left, right) {
// 2. 确定终止条件 空的情况
if(left === null && right !== null || left !== null && right === null) {
return false;
} else if(left === null && right === null) {
return true;
} else if(left.val !== right.val) {
return false;
}
// 3. 确定单层递归逻辑
let outSide = compareNode(left.left, right.right);
let inSide = compareNode(left.right, right.left);
return outSide && inSide;
}
if(root === null) {
return true;
}
return compareNode(root.left, root.right);
};