二叉查找树(英语:Binary Search Tree),也称为二叉搜索树、有序二叉树(ordered binary tree)或排序二叉树(sorted binary tree),是指一棵空树或者具有下列性质的二叉树:
若任意节点的左子树不空,则左子树上所有节点的值均小于它的根节点的值;
若任意节点的右子树不空,则右子树上所有节点的值均大于或等于它的根节点的值;
任意节点的左、右子树也分别为二叉查找树;
二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低。为{\displaystyle O(\log n)}O(\log n)。二叉查找树是基础性数据结构,用于构建更为抽象的数据结构,如集合、多重集、关联数组等。
二叉查找树的查找过程和次优二叉树类似,通常采取二叉链表作为二叉查找树的存储结构。中序遍历二叉查找树可得到一个关键字的有序序列,一个无序序列可以透过建构一棵二叉查找树变成一个有序序列,建构树的过程即为对无序序列进行查找的过程。每次插入的新的结点都是二叉查找树上新的叶子结点,在进行插入操作时,不必移动其它结点,只需改动某个结点的指针,由空变为非空即可。搜索、插入、删除的复杂度等于树高,期望{\displaystyle O(\log n)}O(\log n),最坏{\displaystyle O(n)}O(n)(数列有序,树退化成线性表)。
虽然二叉查找树的最坏效率是{\displaystyle O(n)}O(n),但它支持动态查询,且有很多改进版的二叉查找树可以使树高为{\displaystyle O(\log n)}O(\log n),从而将最坏效率降至{\displaystyle O(\log n)}O(\log n),如AVL树、红黑树等。
public class BinarySearchTree<E extends Comparable<E>> {
private class Node {
E e;
Node left, right;
Node(E e) {
this.e = e;
left = right = null;
}
}
private Node root;
private int size;
public boolean isEmpty() {
return size == 0;
}
public int size() {
return size;
}
public void add(E e) {
root = add(root, e);
}
private Node add(Node node, E e) {
if (node == null) {
size++;
return new Node(e);
}
if (node.e.compareTo(e) > 0) {
node.left = add(node.left, e);
} else if (node.e.compareTo(e) < 0) {
node.right = add(node.right, e);
}
return node;
}
public boolean contains(E e) {
Node node = getNode(e);
return node != null;
}
private Node getNode(E e) {
return getNode(root, e);
}
private Node getNode(Node node, E e) {
if (node == null) {
return null;
}
if (node.e.compareTo(e) == 0) {
return node;
} else if (node.e.compareTo(e) > 0) {
return getNode(node.left, e);
} else {
return getNode(node.right, e);
}
}
public void remove(E e) {
root = remove(root, e);
}
private Node remove(Node node, E e) {
if (node == null) {
return null;
}
if (node.e.compareTo(e) > 0) {
node.left = remove(node.left, e);
return node;
} else if (node.e.compareTo(e) < 0) {
node.right = remove(node.right, e);
return node;
} else {
if (node.left == null) {
Node right = node.right;
node.right = null;
size--;
return right;
}
if (node.right == null) {
Node left = node.left;
node.left = null;
size--;
return left;
}
Node successor = minimum(node.right);
successor.left = node.left;
successor.right = removeMin(node.right);
node.left = node.right = null;
return successor;
}
}
private Node minimum(Node node) {
if (node.left == null) {
return node;
}
return minimum(node.left);
}
private Node removeMin(Node node) {
if (node.left == null) {
Node right = node.right;
node.right = null;
size--;
return right;
}
node.left = removeMin(node.left);
return node;
}
public static void main(String[] args) {
BinarySearchTree<Integer> bst = new BinarySearchTree<>();
for (int i = 0; i < 10; i++) {
bst.add(i);
}
for (int i = 0; i < 10; i++) {
bst.remove(i);
}
System.out.println(bst.isEmpty());
}
}