两个情况分别判断：
二叉搜索树：每个节点左边节点小于右边节点，左子树的最大值一定小于根节点，小于右子树的最大值；通过中序遍历，严格递增
当root为null时，肯定是一个二叉搜索树
TreeNode root val 为int 则 最小值Integer.MIN_VALUE, 最大值Integer.MAX_VALUE
root.left 最小值为Integer.MIN_VALUE 最大值为 root.val
root.left.left 最小值为Integer.MIN_VALUE 最大值为 root.left.val
root.left.left.left 最小值为Integer.MIN_VALUE 最大值为 root.left.left.val
root.left.right 最小值为root.left.val 最大值为 root.val
root.left.right.left 最小值为root.left.val 最大值为 root.left.right.val
此处采用递归思想
当前节点为null 返回true
当前节点的值小于最小值 或者大于最大值返回 false
当前节点左节点的最大值为 当前节点的值 最小值为父节点的最小值
当前节点的右节点的最小值为当前节点的值 最大值为父节点的最大值
完全二叉树：层序遍历，除了最后的一层，每层都是满的
完全二叉树的每一层节点都是满的 ，最后一层节点 空节点的右侧没有节点 一个节点有左节点才能有右节点

/*

  • public class TreeNode {
  • int val = 0;
  • TreeNode left = null;
  • TreeNode right = null;
  • }
  • /

public class Solution {
/**
*
* @param root TreeNode类 the root
* @return bool布尔型一维数组
/
/*
* // 两个情况分别判断： // 二叉搜索树：每个节点左边节点小于右边节点，左子树的最大值一定小于根节点，小于右子树的最大值；通过中序遍历，严格递增 //
* 完全二叉树：层序遍历，除了最后的一层，每层都是满的
*
* @param root
* TreeNode类 the root
* @return bool布尔型一维数组
/
public boolean[] judgeIt(TreeNode root) {
boolean[] flag = new boolean[2];
flag[0] = isBST(root, Integer.MIN_VALUE, Integer.MAX_VALUE);
flag[1] = isComplete(root);
return flag;
}
/*
* 二叉树搜索树， 做节点小于根节点 右节点大于根节点
* @param root
* @param min
* @param max
* @return
/
public boolean isBST(TreeNode root, int min, int max) {
if(root == null) {
return true;
}
if(root.val <min || root.val > max) {
return false;
}
return isBST(root.left, min, root.val) && isBST(root.right, root.val, max);
}
/*
* 完全二叉树 一个节点 有左节点才能有右节点，如果 一个节点的子节点为空则下一level的这个子节点的右侧没有节点
* @param node
* @return
*/
public boolean isComplete(TreeNode node) {
LinkedList<treenode> queue = new LinkedList<>();
queue.offer(node);
while(!queue.isEmpty()) {
TreeNode treeNode = queue.poll();
if(treeNode == null) {
break;
}
queue.offer(treeNode.left);
queue.offer(treeNode.right);
}
while(!queue.isEmpty()) {
TreeNode treeNode = queue.poll();
if(treeNode != null) {</treenode>

                 return false;
             }
         }
         return true;
}

}