承接上文:Java-数据结构-二叉树<一>
一. 二叉树的简单介绍
见Java-数据结构-二叉树<一>
二. 二叉树的典型代码实现
见Java-数据结构-二叉树<一>
三. 二叉树的遍历
见Java-数据结构-二叉树<一>
四. leetcode实战
1~2 见 Java-数据结构-二叉树<一>
3. leetcode100 相同的树
给你两棵二叉树的根节点 p 和 q ,编写一个函数来检验这两棵树是否相同。如果两个树在结构上相同,并且节点具有相同的值,则认为它们是相同的。
输入:p = [1,2,3], q = [1,2,3]
输出:true
class Solution {
boolean flag = true;
public boolean isSameTree(TreeNode p, TreeNode q) {
dfs(p,q);
return flag;
}
public void dfs(TreeNode root1, TreeNode root2){
if(root1 == null && root2 == null){
return;
}
if(root1 == null && root2 != null){
flag = false;
return;
}
if(root1 != null && root2 == null){
flag = false;
return;
}
if(root1.val != root2.val){
flag = false;
return;
}
dfs(root1.left,root2.left);
dfs(root1.right,root2.right);
}
}
精简版
class Solution {
public boolean isSameTree(TreeNode p, TreeNode q) {
if (p == null && q == null) {
return true;
} else if (p == null || q == null) {
return false;
} else if (p.val != q.val) {
return false;
} else {
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}
}
}
4. leetcode101 对称二叉树
给你一个二叉树的根节点 root , 检查它是否轴对称。
输入:root = [1,2,2,3,4,4,3]
输出:true
class Solution {
boolean flag = true;
public boolean isSymmetric(TreeNode root) {
if(root == null) return true;
dfs(root.left,root.right);
return flag;
}
public void dfs(TreeNode root1, TreeNode root2){
if(root1 == null && root2 == null){
return;
}
if(root1 != null && root2 == null){
flag = false;
return;
}
if(root1 == null && root2 != null){
flag = false;
return;
}
if(root1.val != root2.val){
flag = false;
return;
}
dfs(root1.left,root2.right);
dfs(root2.left,root1.right);
}
}
本题小结:(1)这题和 第三题本质一样,本质都在遍历并比较
(2)不一样的是遍历的方向,要注意左右之分。
5. leetcode110 平衡二叉树
给定一个二叉树,判断它是否是高度平衡的二叉树。本题中,一棵高度平衡二叉树定义为:一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
输入:root = [3,9,20,null,null,15,7]
输出:true
自下向上
public class BalancedBinaryTree {
boolean res = true;
public boolean isBalanced(TreeNode root) {
helper(root);
return res;
}
private int helper(TreeNode root) {
if (root == null) return 0;
int left = helper(root.left) + 1;
int right = helper(root.right) + 1;
if (Math.abs(right - left) > 1) res = false;
return Math.max(left, right);
}
}
自定向下
class Solution {
public boolean isBalanced(TreeNode root) {
if (root == null) return true;
return Math.abs(depth(root.left) - depth(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
}
private int depth(TreeNode root) {
if (root == null) return 0;
return Math.max(depth(root.left), depth(root.right)) + 1;
}
}
6. leetcode226 翻转二叉树
给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。
输入:root = [4,2,7,1,3,6,9]
输出:[4,7,2,9,6,3,1]
递归 先递归后交换
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null) return root;
TreeNode left = invertTree(root.left);
TreeNode right = invertTree(root.right);
root.left = right;
root.right = left;
return root;
}
}
递归 先交换后递归
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null) return root;
TreeNode temp = root.left;
root.left = root.right;
root.right = temp;
invertTree(root.left);
invertTree(root.right);
return root;
}
}
层序遍历
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root == null) return root;
Deque<TreeNode> list = new ArrayDeque<>();
list.add(root);
while(!list.isEmpty()){
TreeNode node = list.pop();
TreeNode temp = node.left;
node.left = node.right;
node.right = temp;
if(node.left != null){
list.add(node.left);
}
if(node.right != null){
list.add(node.right);
}
}
return root;
}
}
7. leetcode543 二叉树直径
给定一棵二叉树,你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。
返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。
class Solution {
int res = 0;
public int diameterOfBinaryTree(TreeNode root) {
dfs(root);
return res;
}
// 函数dfs的作用是:找到以root为根节点的二叉树的最大深度
public int dfs(TreeNode root){
if(root == null){
return 0;
}
int leftDepth = dfs(root.left);
int rigthDepth = dfs(root.right);
res = Math.max(res,leftDepth + rigthDepth);
return Math.max(leftDepth,rigthDepth) + 1;
}
}
8. leetcode617 合并二叉树
给你两棵二叉树: root1 和 root2 。想象一下,当你将其中一棵覆盖到另一棵之上时,两棵树上的一些节点将会重叠(而另一些不会)。你需要将这两棵树合并成一棵新二叉树。合并的规则是:如果两个节点重叠,那么将这两个节点的值相加作为合并后节点的新值;否则,不为 null 的节点将直接作为新二叉树的节点。返回合并后的二叉树。注意: 合并过程必须从两个树的根节点开始。
输入:root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出:[3,4,5,5,4,null,7]
class Solution {
public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
if(root1 == null) return root2;
if(root2 == null) return root1;
root1.val += root2.val;
root1.left = mergeTrees(root1.left,root2.left);
root1.right = mergeTrees(root1.right,root2.right);
return root1;
}
}
9. leetcode108 将有序数组转换为二叉搜索树
给你一个整数数组 nums ,其中元素已经按 升序 排列,请你将其转换为一棵 高度平衡 二叉搜索树。高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。
输入:nums = [-10,-3,0,5,9]
输出:[0,-3,9,-10,null,5]
解释:[0,-10,5,null,-3,null,9] 也将被视为正确答案:
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
return dfs(nums,0,nums.length-1);
}
public TreeNode dfs(int[] nums, int left, int right){
if(left > right){
return null;
}
int mid = (left+right)/2;
TreeNode root = new TreeNode(nums[mid]);
root.left = dfs(nums, left ,mid-1);
root.right = dfs(nums, mid+1, right);
return root;
}
}
10. leetcode700 二叉搜索树中的搜索
给定二叉搜索树(BST)的根节点 root 和一个整数值 val。你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在,则返回 null 。
输入:root = [4,2,7,1,3], val = 2
输出:[2,1,3]
class Solution {
public TreeNode searchBST(TreeNode root, int val) {
if(root == null) return null;
if(root.val == val) return root;
if(root.val > val) return searchBST(root.left,val);
return searchBST(root.right,val);
}
}
11. leetcode938 二叉搜索树的范围和
给定二叉搜索树的根结点 root,返回值位于范围 [low, high] 之间的所有结点的值的和。
输入:root = [10,5,15,3,7,null,18], low = 7, high = 15
输出:32
class Solution {
public int rangeSumBST(TreeNode root, int low, int high) {
if(root == null) return 0;
if(root.val < low) return rangeSumBST(root.right, low, high);
if(root.val > high) return rangeSumBST(root.left, low, high);
return root.val + rangeSumBST(root.right, low, high)+ rangeSumBST(root.left, low, high);
}
}
参考自
【1】leetcode powcai 自顶向下和自底向上
【2】leetcode Krahets 平衡二叉树(从底至顶,从顶至底)
【3】leetcode sugar Java 深度优先遍历 DFS
【4】leetcode Sweetiee 🍬 简单递归,🤷♀️ 必须秒懂!