问题1：判断是不是二叉搜索树
原题点击：判断是不是二叉搜索树
题目描述：
给定一个二叉树根节点，请你判断这棵树是不是二叉搜索树。
二叉搜索树满足每个节点的左子树上的所有节点均小于当前节点且右子树上的所有节点均大于当前节点。
例：
图1
图2
数据范围：
节点数量满足 1 ≤n≤ 10^4
节点上的值满足：
示例1：
输入： {1,2,3}
返回值： false
说明：如题面图1
示例2：
输入： {2,1,3}
返回值： true
说明：如题面图2
题解：
Java代码实现：
import java.util.*; public class Solution { 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：判断是不是完全二叉树
原题点击：判断是不是完全二叉树
题目描述：
给定一个二叉树，确定他是否是一个完全二叉树。
完全二叉树的定义：若二叉树的深度为 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<TreeNode> 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：判断是不是平衡二叉树
原题点击：判断是不是平衡二叉树
题目描述：
输入一棵节点数为 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：二叉搜索树的最近公共祖先
原题点击：二叉搜索树的最近公共祖先
题目描述：
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。
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<Integer> getPath(TreeNode root, int target) { ArrayList<Integer> path = new ArrayList<Integer>(); 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<Integer> path_p = getPath(root, p); ArrayList<Integer> 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：序列化二叉树
原题点击：序列化二叉树
题目描述：
请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。
二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#）
二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
例如，可以根据层序遍历的方案序列化，如下图:
层序序列化(即用函数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; } public TreeNode Deserialize(String str) { //空序列对应空树 if(str == "#") return null; TreeNode res = DeserializeFunction(str); return res; } }
思路： 序列化即将二叉树的节点值取出，放入一个字符串中，我们可以按照前序遍历的思路，遍历二叉树每个节点，并将节点值存储在字符串中，我们用‘#’表示空节点，用‘!'表示节点与节点之间的分割。
反序列化即根据给定的字符串，将二叉树重建，因为字符串中的顺序是前序遍历，因此我们重建的时候也是前序遍历，即可还原。
