Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
🌱🌱个人主页：奋斗的明志
🌱🌱所属专栏：数据结构、LeetCode专栏
📚本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。
二叉树面试题
- 前言
- 一、相同的树
- 1. 题目
- 2. 解析
- 3. 完整代码
- 二、另一棵树的子树
- 1. 题目
- 2. 解析（深度优先搜索暴力匹配）
- 3. 完整代码
- 4.深度优先搜索序列上做串匹配
- 三、翻转二叉树
- 1.题目
- 2.解析（利用深度优先搜索）
- 3.完整代码
- 四、总结
前言
一定要结合图像来写题，递归有点绕
一、相同的树
100.相同的树
1. 题目
2. 解析
- 一个为空，一个不为空，说明不是两棵相同的树
- 如果两个都为空，说明是相同的树
- 两个都不为空，但是值不一样，说明不是两棵相同的树
isSameTree 方法解释：
-
参数：方法接收两个 TreeNode 类型的参数 p 和 q，分别代表两棵二叉树的根节点。
返回值：返回一个布尔值，表示两棵树是否相同。 -
逻辑：
首先，通过判断根节点的情况来确定树的结构是否相同：
如果 p 为 null 而 q 不为 null，或者 p 不为 null 而 q 为 null，则树的结构不同，返回 false。
如果两个根节点都为 null，说明两棵树为空树，返回 true。
如果根节点的值 p.val 不等于 q.val，则根节点的值不同，返回 false。
如果根节点的值相同，则递归地比较它们的左子树和右子树，判断左右子树是否相同。
递归调用：
- isSameTree(p.left, q.left) 递归地比较两棵树的左子树。
- isSameTree(p.right, q.right) 递归地比较两棵树的右子树。
- 最终，通过递归的方式，判断了整棵树的结构和节点值是否完全相同。
这段代码利用递归的思想，深度优先地比较了两棵二叉树的结构和节点值，判断它们是否相同。
3. 完整代码
/**
* 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 isSameTree(TreeNode p, TreeNode q) {
//首先判断根节点
if((p == null && q != null) || (p != null && q == null)){
//结构不一样
return false;
}
//如果上面if语句没有走 说明 剩下两个都为空 或者 两个都不为空
if(p == null && q == null){
//说明两个为空
return true;
}
if(p.val != q.val){
return false;//说明根节点的值不一样
}
//以下就是根节点的值一样 判断 左右子树的值是否一样
//利用递归
return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
}
二、另一棵树的子树
写这一道题，要深入理解第一道题，因为要用到
527.另一棵树的子树
1. 题目
2. 解析（深度优先搜索暴力匹配）
- 从根节点开始判断，如果主树为空的话，则不可能包含子树
【isSubtree方法】
3. 完整代码
/**
* 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 isSubtree(TreeNode root, TreeNode subRoot) {
if(root == null){
return false;
}
if(isSametree(root,subRoot)){
return true;
}
if(isSubtree(root.left,subRoot)){
return true;
}
if(isSubtree(root.right,subRoot)){
return true;
}
return false;
}
public boolean isSametree(TreeNode p,TreeNode q){
if((p != null && q == null) || (p == null && q != null)){
return false;
}
if(p == null && q == null){
return true;
}
if(p.val != q.val){
return false;
}
return isSametree(p.left,q.left) && isSametree(p.right,q.right);
}
}
4.深度优先搜索序列上做串匹配
class Solution {
List<Integer> sOrder = new ArrayList<Integer>();
List<Integer> tOrder = new ArrayList<Integer>();
int maxElement, lNull, rNull;
public boolean isSubtree(TreeNode s, TreeNode t) {
maxElement = Integer.MIN_VALUE;
getMaxElement(s);
getMaxElement(t);
lNull = maxElement + 1;
rNull = maxElement + 2;
getDfsOrder(s, sOrder);
getDfsOrder(t, tOrder);
return kmp();
}
public void getMaxElement(TreeNode t) {
if (t == null) {
return;
}
maxElement = Math.max(maxElement, t.val);
getMaxElement(t.left);
getMaxElement(t.right);
}
public void getDfsOrder(TreeNode t, List<Integer> tar) {
if (t == null) {
return;
}
tar.add(t.val);
if (t.left != null) {
getDfsOrder(t.left, tar);
} else {
tar.add(lNull);
}
if (t.right != null) {
getDfsOrder(t.right, tar);
} else {
tar.add(rNull);
}
}
public boolean kmp() {
int sLen = sOrder.size(), tLen = tOrder.size();
int[] fail = new int[tOrder.size()];
Arrays.fill(fail, -1);
for (int i = 1, j = -1; i < tLen; ++i) {
while (j != -1 && !(tOrder.get(i).equals(tOrder.get(j + 1)))) {
j = fail[j];
}
if (tOrder.get(i).equals(tOrder.get(j + 1))) {
++j;
}
fail[i] = j;
}
for (int i = 0, j = -1; i < sLen; ++i) {
while (j != -1 && !(sOrder.get(i).equals(tOrder.get(j + 1)))) {
j = fail[j];
}
if (sOrder.get(i).equals(tOrder.get(j + 1))) {
++j;
}
if (j == tLen - 1) {
return true;
}
}
return false;
}
}
三、翻转二叉树
226.翻转二叉树
1.题目
2.解析（利用深度优先搜索）
- 首先要进行空树检查
- 进行单节点树检查
- 翻转操作：首先创建一个临时节点 tmp，将 root 的左右子树交换。这里直接交换了节点的引用，而不是交换节点的值。
- 递归地对 root 的左子树和右子树进行翻转操作。
- 返回经过翻转处理后的根节点 root
3.完整代码
/**
* 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 TreeNode invertTree(TreeNode root) {
//空树
if(root == null){
return null;
}
//只有一个节点的树
if(root.left == null && root.right == null && root.val >= -100 && root.val <= 100){
return root;
}
//定义一个中间结点
TreeNode tmp = new TreeNode();
tmp.left = root.left;
tmp.right = root.right;
root.left = tmp.right;
root.right = tmp.left;
invertTree(root.left);
invertTree(root.right);
return root;
}
}
【改进后的代码】
class Solution {
public TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
// 交换左右子树
TreeNode left = invertTree(root.left);
TreeNode right = invertTree(root.right);
root.left = right;
root.right = left;
return root;
}
}
这个简化版本避免了使用额外的临时节点，并且更加清晰地表达了翻转操作
四、总结
将大问题划分成一个一个相同的小问题来求解，一定要注意判断条件
