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) {
return 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;
}
}