二叉查找树(Binary Search Tree),(又:二叉搜索树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值; 若它的右子树不空,则右子树上所有结点的值均大于它的根结点的值; 它的左、右子树也分别为二叉排序树。
关键点:空树 每颗子树均满足结点打印左子树上所有的值,均小于右子树上所有结点的值。
一种比较简单的实现方式,就是树的中序遍历结果,是升序就满足条件
/**
* 中序升序就是二叉排序树
*/
private static boolean isBinarySearchTreeV2 (TreeNode<Integer> root) {
List<Integer> list = in(root);
if (list==null || list.isEmpty()) return true;
ArrayList<Integer> arrayList = new ArrayList<>(list);
int size = arrayList.size();
for (int i = 1; i < size; i++) {
if (arrayList.get(i-1) >= arrayList.get(i) ) {
return false;
}
}
return true;
}
/**
* 中序遍历
*/
private static List<Integer> in(TreeNode<Integer> root) {
if (root == null) {
return null;
}
List<Integer> list = new LinkedList<>();
List<Integer> leftList = in(root.left);
if (leftList!=null && !leftList.isEmpty()) {
list.addAll(leftList);
}
list.add(root.val);
List<Integer> rightList = in(root.right);
if (rightList!=null && !rightList.isEmpty()) {
list.addAll(rightList);
}
return list;
}
较为复杂的一种实现方式,每颗子树均满足结点打印左子树上所有的值,均小于右子树上所有结点的值。左子树、右子树、当前树
private static boolean isBinarySearchTree (TreeNode<Integer> root) {
if (root == null) {
return true;
}
if (root.left == null && root.right==null) return true;
return processBST(root).isBST;
}
private static BinarySearchTreeInfo processBST(TreeNode<Integer> root) {
if (root == null) {
/*此时是二叉搜索树
* 但是最大值最小值返回什么都不合适: 0 结点有负值不合适;int的最大和最小,结点中若有不合适
* 故不创建对象返回*/
return null;
}
if (root.left == null && root.right==null) {
return new BinarySearchTreeInfo(true, root.val, root.val);
}
BinarySearchTreeInfo leftBinarySearchTreeInfo = processBST(root.left);
BinarySearchTreeInfo rightBinarySearchTreeInfo = processBST(root.right);
BinarySearchTreeInfo bstInfo = new BinarySearchTreeInfo(false, root.val, root.val);
/*(左子树是否满足条件)左子树空 直接就满足二叉搜索,不空取属性
* (右子树是否满足条件)右子树空 直接就满足二叉搜索 不空取属性
* (当前树是否满足条件)左子树不空比较结点与左子树的最大值,右子树不空比较右子树的最小值*/
if ((leftBinarySearchTreeInfo==null || (leftBinarySearchTreeInfo.isBST && root.val>leftBinarySearchTreeInfo.maxValue))
&& (rightBinarySearchTreeInfo==null || (rightBinarySearchTreeInfo.isBST && root.val<rightBinarySearchTreeInfo.minValue))) {
bstInfo.setBST(true);
}
if (leftBinarySearchTreeInfo!=null) {
bstInfo.setMaxValue(Math.max(bstInfo.getMaxValue(), leftBinarySearchTreeInfo.maxValue));
bstInfo.setMinValue(Math.min(bstInfo.getMinValue(), leftBinarySearchTreeInfo.minValue));
}
if (rightBinarySearchTreeInfo!=null) {
bstInfo.setMaxValue(Math.max(bstInfo.getMaxValue(), rightBinarySearchTreeInfo.getMaxValue()));
bstInfo.setMinValue(Math.min(bstInfo.getMinValue(), rightBinarySearchTreeInfo.getMinValue()));
}
return bstInfo;
}
private static class BinarySearchTreeInfo{
private boolean isBST;//是否二插搜索树
private int minValue;
private int maxValue;
public BinarySearchTreeInfo() {
}
public BinarySearchTreeInfo(boolean isBST, int minValue, int maxValue) {
this.isBST = isBST;
this.minValue = minValue;
this.maxValue = maxValue;
}
public boolean isBST() {
return isBST;
}
public void setBST(boolean BST) {
isBST = BST;
}
public int getMaxValue() {
return maxValue;
}
public void setMaxValue(int maxValue) {
this.maxValue = maxValue;
}
public int getMinValue() {
return minValue;
}
public void setMinValue(int minValue) {
this.minValue = minValue;
}
}