二叉查找树是具有如下性质的一种二叉树：对于任一结点x，x的左子树结点的关键字均不大于x，右子树结点的关键字均不小于x。

二叉查找树的特点是位置决定了顺序，所以在不对关键字进行排序的情况下，通过位置关系就能找到特定大小的关键字结点。例如，对二叉查找树进行中根遍历就能按升序输出所有的关键字。

二叉查找树的搜索：从根节点开始，对于树中任一结点k，若k的关键字大于待搜索的值x，则搜索k的左子树；若小于，则搜索k的右子树；若等于，则找到。

最大关键字和最小关键字：最大关键字是二叉查找树的最右叶结点，最小关键字是最左叶结点。

前趋和后继：某结点的前趋是指关键字比该结点小的所有结点中最大的一个，而后继则是关键字比该结点大的所有结点中最小的一个。就后继而言：

1.      若结点x的右子树非空，则x的后继是x的右子树的最左叶结点；

2.      若结点x的右子树为空，则x的后继是x的最低祖先结点，且该后继结点的左儿子也必须是x的祖先。

前趋则跟后继正好对称。

插入：与二叉查找树的搜索相类似，小于当前结点的值则向左，大于当前结点的值则向右，最终将待插入的值作为满足当前二叉查找树性质的某个叶结点。

删除：对于待删结点z：

1.      若z没有左右子结点（即z为叶结点），直接删除z；

2.      若z只有一个子结点，删除z，并将z的子结点接到z的父结点的对应位置；

3.      若z左右子结点都有，则找到z的后继y，删除y（以1或2中的方式，因为后继必然至多有一个子结点），再将y的数据拷贝到z中。

二叉查找树的好处是它的上述7种操作（搜索、最大、最小、前趋、后继、插入、删除）的时间复杂度都是O(h)，其中h是二叉树的树高。因此它的最差时间复杂度也才只有O(n)，平均和最佳时间复杂度有只有O(lgn)。

如下是二叉查找树的一种Java实现：

package cn.liujian;

public class BinaryTreeNode<E extends Comparable<E>> {
	private E value;
	private BinaryTreeNode<E> left;
	private BinaryTreeNode<E> right;
	private BinaryTreeNode<E> parent;
	
	public BinaryTreeNode(E e) {
		if (e == null) {
			throw new IllegalArgumentException();
		}
		
		value = e;
		left = null;
		right = null;
		parent = null;
	}
	
	public E getValue() {
		return value;
	}
	public void setValue(E value) {
		if (value == null) {
			throw new IllegalArgumentException();
		}
		
		this.value = value;
	}
	public BinaryTreeNode<E> getLeft() {
		return left;
	}
	public void setLeft(BinaryTreeNode<E> left) {
		this.left = left;
	}
	public BinaryTreeNode<E> getRight() {
		return right;
	}
	public void setRight(BinaryTreeNode<E> right) {
		this.right = right;
	}
	public BinaryTreeNode<E> getParent() {
		return parent;
	}
	public void setParent(BinaryTreeNode<E> parent) {
		this.parent = parent;
	}

	// 为以本结点为根的子树插入新结点
	public void addChild(BinaryTreeNode<E> child) {
		if (child.getValue() == null) {
			throw new IllegalArgumentException();
		}
		
		if (child.getValue().compareTo(value) <= 0) {
			if (left == null) {
				left = child;
				child.setParent(this);
			} else {
				left.addChild(child);
			}
		} else {
			if (right == null) {
				right = child;
				child.setParent(this);
			} else {
				right.addChild(child);
			}
		}
	}
	
	// 二叉树搜索
	public BinaryTreeNode<E> searchNode(E value) {
		if (value == null) {
			return null;
		}
		
		// 递归实现
		if (this.value.compareTo(value) == 0) {
			return this;
		} else if (this.value.compareTo(value) > 0) {
			return (left != null) ? left.searchNode(value) : null;
		} else {
			return (right != null) ? right.searchNode(value) : null;
		}
		
//		// 迭代实现
//		BinaryTreeNode<E> target = this;
//		while (target != null && target.getValue().compareTo(value) != 0) {
//			if (target.getValue().compareTo(value) > 0) {
//				target = target.getLeft();
//			} else {
//				target = target.getRight();
//			}
//		}
//		return target;
	}
	
	// 从以本结点为根的子树中删除结点
	public BinaryTreeNode<E> deleteNode(E value, BinaryTreeNode<E> root) {
		BinaryTreeNode<E> node = searchNode(value);
		
		BinaryTreeNode<E> target = node;
		if (node != null) {
			if (node.getLeft() != null && node.getRight() != null) {
				target = node.successor();
			}
			
			BinaryTreeNode<E> child = (target.getLeft() != null) ? target.getLeft() : target.getRight();
			if (child != null) {
				child.setParent(target.getParent());
			}
			
			if (target.getParent() == null) {
				root = child;
			} else {
				if (target.getParent().getLeft() == target) {
					target.getParent().setLeft(child);
				} else {
					target.getParent().setRight(child);
				}
			}
			
			if (target != node) {
				node.setValue(target.getValue());
			}
		}
		
		
		return target;
	}
	
	// 返回本子树中的最小结点
	public BinaryTreeNode<E> getMinNode() {
		BinaryTreeNode<E> target = this;
		while (target.getLeft() != null) {
			target = target.getLeft();
		}
		return target;
	}
	
	// 返回本子树中的最大结点
	public BinaryTreeNode<E> getMaxNode() {
		BinaryTreeNode<E> target = this;
		while (target.getRight() != null) {
			target = target.getRight();
		}
		return target;
	}
	
	// 返回本结点的后继结点
	public BinaryTreeNode<E> successor() {
		if (right != null) {
			return right.getMinNode();
		}
		
		BinaryTreeNode<E> target = parent;
		BinaryTreeNode<E> child = this;
		while (target != null && child == target.getRight()) {
			child = target;
			target = target.getParent();
		}
		return target;
	}
	
	// 返回本结点的前趋结点
	public BinaryTreeNode<E> predecessor() {
		if (left != null) {
			return left.getMaxNode();
		}
		
		BinaryTreeNode<E> target = parent;
		BinaryTreeNode<E> child = this;
		while (target != null && child == target.getLeft()) {
			child = target;
			target = target.getParent();
		}
		return target;
	}
}

基于这样一棵二叉查找树，可以很容易根据位置关系找到一组数据的顺序中间值（第m = size / 2 + 1小的值）。当然，需要对上述代码进行修改，以得到二叉查找树的大小size、根结点左子树结点数a和根结点右子树结点数b。思路是：

1.      若a = m – 1，则根结点就是中间值；

2.      若a > m – 1，则中间值在根结点的左子树中，且是根结点的第a – m + 1个前趋；

3.      若a < m – 1，则中间值在根结点的右子树中，且是根结点的第b + m – size个后继。

可见，如果用二叉查找树来查找中间值，其运行时间始终是线性的，而且如果树平衡度高的话，运行时间也更少。