1. 判断一棵二叉树是否为搜索二叉树和完全二叉树

验证二叉搜索树

二叉树的完全性检验

1.1. 问题

给定二叉树的一个头节点 head，已知其中没有重复值的节点，实现两个函数分别判断这棵二叉树是否为搜索二叉树和完全二叉树。

1.2. 思路

判断是否是搜索二叉树可用中序遍历一遍，倘若是递增序列，则为搜索二叉树。

判断是否是完全二叉树：

• 方法一：可以用层序遍历（广度优先），当发现一个节点的左子节点或右子节点为空时，那么接下来都不能在遇到子节点。

• 方法二：可以用深度优先搜索。一个完全二叉树可以表示为一个堆，我们在进行遍历的时候给二叉树的节点进行编号，然后将最大编号跟节点数量进行比较，如果相同则是完全二叉树，不同那么则不是。

判断一个树是否为完全搜索二叉树时，可以将判断搜索二叉树的方法和判断完全二叉树的方法二进行合并。

1.3. 代码

1.3.1. 判断是否为搜索二叉树

手动用栈模拟：

public static boolean isBST(TreeNode<Integer> root) {
if (root == null) return true;
Stack<TreeNode<Integer>> stack = new Stack<>();
TreeNode<Integer> cur = root;
TreeNode<Integer> pre = null;
while (!stack.empty() || cur != null) {
if (cur != null) {
stack.push(cur);
cur = cur.left;
} else {
cur = stack.pop();
if (pre != null && pre.val > cur.val)
return false;
pre = cur;
cur = cur.right;
}
}
return true;
}

递归：

class Solution {
private long previousNodeVal = Long.MIN_VALUE;

public boolean isValidBST(TreeNode root) {
if(root == null) {
return true;
}

if(!isValidBST(root.left)) {
return false;
}

long val = root.val;
if(val <= previousNodeVal) {
return false;
}
previousNodeVal = val;

return isValidBST(root.right);
}
}

递归的分支优化：

当一个方法中有很多检查语句，不通过返回false的话，那么我们可以将整个方法预设返回false，只用聚焦在返回为true的情况，这样会让代码更清晰。

class Solution {
double last = -Double.MAX_VALUE;

public boolean isValidBST(TreeNode root) {
if (root == null) {
return true;
}
if (isValidBST(root.left)) {
if (last < root.val) {
last = root.val;
return isValidBST(root.right);
}
}
return false;
}
}

1.3.2. 判断是否为完全二叉树

广度优先（层序遍历）：

public static boolean isCBT(TreeNode<Integer> root) {
if (root == null) return true;
Queue<TreeNode<Integer>> queue = new LinkedList<>();
TreeNode<Integer> node = root;
queue.add(node);
boolean isChildAllowed = true;
while (!queue.isEmpty()) {
node = queue.remove();
if (node.left != null) {
if (!isChildAllowed) return false;
queue.add(node.left);
} else {
isChildAllowed = false;
}

if (node.right != null) {
if (!isChildAllowed) return false;
queue.add(node.right);
} else {
isChildAllowed = false;
}
}
return true;
}

深度优先：

class Solution {
private int count = 0;
private int maxNum = 0;

public  boolean isCompleteTree(TreeNode root) {
if(root == null) {
return true;
}
dfs(root, 1);
return count == maxNum;
}

private void dfs(TreeNode head, int num) {
count++;
maxNum = Math.max(maxNum, num);
if(head.left != null) {
dfs(head.left, num * 2);
}
if(head.right != null) {
dfs(head.right, num * 2 + 1);
}
}