20道真题训练 学会二叉树的前世今生(三)_二叉树真题，2024年最新高级大数据开发开发面试解答之线程篇

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

    queue.offer(root);
    TreeNode cur;
    //定义一个首次出现的标记位
    boolean notComplete = false;
    while(!queue.isEmpty()){
        cur = queue.poll();
        //标记第一次遇到空节点
        if(cur == null){
            notComplete = true;
            continue;
        }
        //后续访问已经遇到空节点了，说明经过了叶子
        if(notComplete)
            return false;
        queue.offer(cur.left);
        queue.offer(cur.right);
    }
    return true;
}

}

**思路：** 对完全二叉树最重要的定义就是叶子节点只能出现在最下层和次下层，所以我们想到可以使用队列辅助进行层次遍历——从上到下遍历所有层，每层从左到右，只有次下层和最下层才有叶子节点，其他层出现叶子节点就意味着不是完全二叉树。




---


## 问题3：判断是不是平衡二叉树


![在这里插入图片描述](https://img-blog.csdnimg.cn/a503e193b43f4e7da5b171f15f1bdc88.png)


原题点击：[判断是不是平衡二叉树]( )


**题目描述：**


输入一棵节点数为 n 二叉树，判断该二叉树是否是平衡二叉树。在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树。


平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。


样例解释：![在这里插入图片描述](https://img-blog.csdnimg.cn/3d8c2359a58043cfb369f8d68bd627d0.png)


样例二叉树如图，为一颗平衡二叉树



> 
> **注：我们约定空树是平衡二叉树。**
> 
> 
> 


**数据范围**：n≤100，树上节点的val值满足 0≤n≤1000


**要求**：空间复杂度O(1)，时间复杂度 O(n)


输入描述：  
 输入一棵二叉树的根节点  
 返回值描述：  
 输出一个布尔类型的值


**示例1：**



> 
> 输入： {1,2,3,4,5,6,7}  
>  返回值： true
> 
> 
> 


**示例2：**



> 
> 输入： {}  
>  返回值： true
> 
> 
> 


**题解：**


Java代码实现：

public class Solution {
//计算该子树深度函数
public int deep(TreeNode root){
//空节点深度为0
if(root == null)
return 0;
//递归算左右子树的深度
int left = deep(root.left);
int right = deep(root.right);
//子树最大深度加上自己
return (left > right) ? left + 1 : right + 1;
}

public boolean IsBalanced\_Solution(TreeNode root) {
    //空树为平衡二叉树
    if (root == null)
        return true;
    int left = deep(root.left);
    int right = deep(root.right);
    //左子树深度减去右子树相差绝对值大于1
    if(left - right > 1 || left - right < -1)
        return false;
    //同时，左右子树还必须是平衡的
    return IsBalanced\_Solution(root.left) && IsBalanced\_Solution(root.right);
}

}

**思路：** 平衡二叉树任意节点两边的子树深度相差绝对值不会超过1，且每个子树都满足这个条件，那我们可以对每个节点找到两边的深度以后：

int deep(TreeNode root){
if(root == null)
return 0;
int left = deep(root.left);
int right = deep(root.right);
//子树最大深度加上自己
return (left > right) ? left + 1 : right + 1;
}

判断是否两边相差绝对值超过1：

//左子树深度减去右子树相差绝对值大于1
if(left - right > 1 || left - right < -1)
return false;

然后因为每个子树都满足这个条件，我们还需要遍历二叉树每个节点当成一棵子树进行判断，而对于每个每个节点判断后，其子节点就是子问题，因此可以用递归。

IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);

---


## 问题4：二叉搜索树的最近公共祖先


![在这里插入图片描述](https://img-blog.csdnimg.cn/9127b16cab6848a4a299d8cf44011ded.png)


原题点击：[二叉搜索树的最近公共祖先]( )


**题目描述：**


给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。


1.对于该题的最近的公共祖先定义:对于有根树T的两个节点p、q，最近公共祖先LCA(T,p,q)表示一个节点x，满足x是p和q的祖先且x的深度尽可能大。在这里，一个节点也可以是它自己的祖先.


2.二叉搜索树是若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值


3.所有节点的值都是唯一的。


4.p、q 为不同节点且均存在于给定的二叉搜索树中。


**数据范围:**  
 3<=节点总数<=10000  
 0<=节点值<=10000


如果给定以下搜索二叉树: {7,1,12,0,4,11,14,#,#,3,5}，如下图:  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/1f433f4b26b44f2d85ecd36502a1aed7.png)


**示例1：**



> 
> 输入： {7,1,12,0,4,11,14,#,#,3,5},1,12  
>  返回值：7
> 
> 
> 


说明：节点1 和 节点12的最近公共祖先是7


**示例2：**



> 
> 输入： {7,1,12,0,4,11,14,#,#,3,5},12,11  
>  返回值： 12
> 
> 
> 


说明：因为一个节点也可以是它自己的祖先.所以输出12


**题解：**


Java代码实现：

import java.util.*;
public class Solution {
//求得根节点到目标节点的路径
public ArrayList getPath(TreeNode root, int target) {
ArrayList path = new ArrayList();
TreeNode node = root;
//节点值都不同，可以直接用值比较
while(node.val != target){
path.add(node.val);
//小的在左子树
if(target < node.val)
node = node.left;
//大的在右子树
else
node = node.right;
}
path.add(node.val);
return path;
}
public int lowestCommonAncestor (TreeNode root, int p, int q) {
//求根节点到两个节点的路径
ArrayList path_p = getPath(root, p);
ArrayList path_q = getPath(root, q);
int res = 0;
//比较两个路径，找到第一个不同的点
for(int i = 0; i < path_p.size() && i < path_q.size(); i++){
int x = path_p.get(i);
int y = path_q.get(i);
//最后一个相同的节点就是最近公共祖先
if(x == y)
res = path_p.get(i);
else
break;
}
return res;
}
}

**思路：** 二叉搜索树没有相同值的节点，因此分别从根节点往下利用二叉搜索树较大的数在右子树，较小的数在左子树，可以轻松找到p、q：

//节点值都不同，可以直接用值比较
while(node.val != target) {
path.add(node.val);
//小的在左子树
if(target < node.val)
node = node.left;
//大的在右子树
else
node = node.right;
}

直接得到从根节点到两个目标节点的路径，这样我们利用路径比较就可以找到最近公共祖先。




---


## 问题5：序列化二叉树


![在这里插入图片描述](https://img-blog.csdnimg.cn/8332342bc5114689abbf8915710f27b3.png)


原题点击：[序列化二叉树]( )


**题目描述：**


请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。


二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#）


二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。


例如，可以根据层序遍历的方案序列化，如下图:  
 ![在这里插入图片描述](https://img-blog.csdnimg.cn/1679d8a00c764bb986324547920eea73.png)


层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}"，再能够调用反序列化(Deserialize)将"{1,2,3,#,#,6,7}"构造成如上的二叉树。


当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。


**数据范围：** 节点数 n≤100，树上每个节点的值满足 0≤val≤150


**要求：** 序列化和反序列化都是空间复杂度 O(n)，时间复杂度 O(n)。


**示例1**



> 
> 输入： {1,2,3,#,#,6,7}  
>  返回值： {1,2,3,#,#,6,7}
> 
> 
> 


说明：如题面图


**示例2**



> 
> 输入： {8,6,10,5,7,9,11}  
>  返回值： {8,6,10,5,7,9,11}
> 
> 
> 


**题解：**


Java代码实现：

import java.util.*;
public class Solution {
//序列的下标
public int index = 0;
//处理序列化的功能函数（递归）
private void SerializeFunction(TreeNode root, StringBuilder str){
//如果节点为空，表示左子节点或右子节点为空，用#表示
if(root == null){
str.append(‘#’);
return;
}
//根节点
str.append(root.val).append(‘!’);
//左子树
SerializeFunction(root.left, str);
//右子树
SerializeFunction(root.right, str);
}

public String Serialize(TreeNode root) {
    //处理空树
    if(root == null)
        return "#";
    StringBuilder res = new StringBuilder();
    SerializeFunction(root, res);
    //把str转换成char
    return res.toString();
}
//处理反序列化的功能函数（递归）
private TreeNode DeserializeFunction(String str){
    //到达叶节点时，构建完毕，返回继续构建父节点
    //空节点
    if(str.charAt(index) == '#'){
        index++;
        return null;
    }
    //数字转换
    int val = 0;
    //遇到分隔符或者结尾
    while(str.charAt(index) != '!' && index != str.length()){
        val = val \* 10 + ((str.charAt(index)) - '0');
        index++;
    }
    TreeNode root = new TreeNode(val);
    //序列到底了，构建完成
    if(index == str.length())
        return root;
    else
        index++;
    //反序列化与序列化一致，都是前序
    root.left = DeserializeFunction(str); 
    root.right = DeserializeFunction(str);
    return root;

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

)
return root;
else
index++;
//反序列化与序列化一致，都是前序
root.left = DeserializeFunction(str);
root.right = DeserializeFunction(str);
return root;

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）
[外链图片转存中…(img-xXGZQXoB-1713690750220)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！