面试基础知识整理 —— 二叉搜索树

1. 定义

二叉查找树（英语：Binary Search Tree），也称二叉搜索树、有序二叉树（英语：ordered binary tree），排序二叉树（英语：sorted binary tree），是指一棵空树或者具有下列性质的二叉树：

若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

任意节点的左、右子树也分别为二叉查找树；

没有键值相等的节点。

摘自维基百科 二叉搜索树

2. 实现

二叉搜索树节点

package tree;

/**
* Created by song on 4/8/17.
*
* 二叉搜索树节点
*/
public class BinaryNode<T extends Comparable> {

private T value;

private BinaryNode<T> left;

private BinaryNode<T> right;

public BinaryNode() {
/*do nothing*/
}

public BinaryNode(T value) {
this(value, null, null);
}

public BinaryNode(T value, BinaryNode<T> left, BinaryNode<T> right) {
this.value = value;
this.left = left;
this.right = right;
}

public T getValue() {
return value;
}

public void setValue(T value) {
this.value = value;
}

public BinaryNode<T> getLeft() {
return left;
}

public void setLeft(BinaryNode<T> left) {
this.left = left;
}

public BinaryNode<T> getRight() {
return right;
}

public void setRight(BinaryNode<T> right) {
this.right = right;
}
}

二叉搜索树

package tree;

/**
* Created by song on 4/8/17.
* <p>
* 二叉搜索树
*/
public class BinarySearchTree<T extends Comparable> {

private BinaryNode<T> root;

public BinarySearchTree() {
this(null);
}

public BinarySearchTree(BinaryNode<T> root) {
this.root = root;
}

public boolean isEmpty() {
return this.root == null;
}

public void clean() {
this.root = null;
}

public T find(T t) {
return valueAt(find(t, root));
}

public T findMin() {
return valueAt(findMin(root));
}

public T findMax() {
return valueAt(findMax(root));
}

public void insert(T t) {
root = insert(t, root);
}

public void remove(T t) {
root = remove(t, root);
}

public void printTree() {

}

private T valueAt(BinaryNode<T> node) {
return node == null ? null : node.getValue();
}

@SuppressWarnings("unchecked")
private BinaryNode<T> find(T x, BinaryNode<T> node) {
if (node == null) {
return null;
}

if (x.compareTo(node.getValue()) < 0) {
return find(x, node.getLeft());
} else if (x.compareTo(node.getValue()) > 0) {
return find(x, node.getRight());
} else {
return node;
}
}

private BinaryNode<T> findMin(BinaryNode<T> node) {
if (node == null) {
return null;
}

if (node.getLeft() == null) {
return node;
}

return findMin(node.getLeft());
}

private BinaryNode<T> findMax(BinaryNode<T> node) {
if (node == null) {
return null;
}

if (node.getRight() == null) {
r
4000
eturn node;
}

return findMax(node.getRight());
}

@SuppressWarnings("unchecked")
private BinaryNode<T> insert(T t, BinaryNode<T> node) {
if (node == null) {
node = new BinaryNode<>(t, null, null);
}

if (t.compareTo(node.getValue()) < 0) {
node = insert(t, node.getLeft());
} else if (t.compareTo(node.getValue()) > 0) {
node = insert(t, node.getRight());
} else {
throw new RuntimeException("duplicate node");
}

return node;
}

@SuppressWarnings("unchecked")
private BinaryNode<T> remove(T t, BinaryNode<T> node) {
if (node == null) {
return null;
}

if (t.compareTo(node.getValue()) < 0) {
node.setLeft(remove(t, node.getLeft()));
} else if (t.compareTo(node.getValue()) > 0) {
node.setRight(remove(t, node.getRight()));
} else if (node.getLeft() != null && node.getRight() != null) {
node.setValue(findMin(node.getRight()).getValue());
node.setRight(remove(node.getValue(), node.getRight()));
} else {
node = (node.getLeft() != null) ? node.getLeft() : node.getRight();
}

return node;
}
}