int pre = Integer.MIN_VALUE;
//中序遍历
public boolean isValidBST (TreeNode root) {
if (root == null)
return true;
//先进入左子树
if(!isValidBST(root.left))
return false;
if(root.val < pre)
return false;
//更新最值
pre = root.val;
//再进入右子树
return isValidBST(root.right);
}
}
**思路：** 二叉搜索树的特性就是中序遍历是递增序。既然是判断是否是二叉搜索树，那我们可以使用中序递归遍历。只要之前的节点是二叉树搜索树，那么如果当前的节点小于上一个节点值那么就可以向下判断。
只不过在过程中我们要求反退出。比如一个链表1->2->3->4，只要for循环遍历如果中间有不是递增的直接返回false即可。
if(root.val < pre)
return false;
---
## 问题2：判断是不是完全二叉树
原题点击：[判断是不是完全二叉树](https://bbs.csdn.net/topics/618545628)
**题目描述：**
给定一个二叉树，确定他是否是一个完全二叉树。
完全二叉树的定义：若二叉树的深度为 h，除第 h 层外，其它各层的结点数都达到最大个数，第 h 层所有的叶子结点都连续集中在最左边，这就是完全二叉树。（第 h 层可能包含 [1~2h] 个节点）
**数据范围：** 节点数满足 1≤n≤100
样例图1：
样例图2：
样例图3：
**示例1：**
>
> 输入： {1,2,3,4,5,6}
> 返回值： true
>
>
>
**示例2：**
>
> 输入： {1,2,3,4,5,6,7}
> 返回值： true
>
>
>
**示例3：**
>
> 输入： {1,2,3,4,5,#,6}
> 返回值： false
>
>
>
**题解：**
Java代码实现：
import java.util.*;
public class Solution {
public boolean isCompleteTree (TreeNode root) {
//空树一定是完全二叉树
if(root == null)
return true;
//辅助队列
Queue queue = new LinkedList<>();
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://bbs.csdn.net/topics/618545628)
**题目描述：**
输入一棵节点数为 n 二叉树，判断该二叉树是否是平衡二叉树。在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树。
平衡二叉树（Balanced Binary Tree），具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
样例解释：
样例二叉树如图，为一颗平衡二叉树
>
> **注：我们约定空树是平衡二叉树。**
>
>
>
**数据范围**：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://bbs.csdn.net/topics/618545628)
**题目描述：**
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
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}，如下图:
**示例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://bbs.csdn.net/topics/618545628)**
**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
else
node = node.right;
}
直接得到从根节点到两个目标节点的路径，这样我们利用路径比较就可以找到最近公共祖先。
问题5：序列化二叉树
[外链图片转存中…(img-G759oS4X-1714639420225)]
[外链图片转存中…(img-rpPolYAR-1714639420226)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
494
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
