数据结构系列：二叉搜索树

1 前言

从二叉搜索树这个名字我们可以大致猜出，它与搜索（查找）相关。而对于一个查找算法，我们关心它查找的速度快不快，时间效率高不高。我们都知道在线性表中顺序查找一个给定元素的时间复杂度为 O(n)，但在二叉搜索树中，查找的时间复杂度可以降为 O(logn)，它是如何做到的呢？

2 二叉搜索树简介

二叉搜索树首先是一棵二叉树，只不过它的要求更苛刻一些。每一个节点除了有左右孩子以外，同时，还需要满足一定顺序，即左孩子的元素比当前节点的元素小，右孩子的元素比当前节点元素大（相等的情况根据不同的应用场景会有不同的处理方式，这里我们暂不讨论）。

2.1 关于比较

那怎么比较元素之间的大小呢？通常我们认为比较大小似乎只能在数值之间进行比较，可在计算机的世界中，任何对象之间都能比较大小，因为我们可以自己定义比较规则。在 Java 中，我们通过实现接口 Comparable 或者 Comparator 为自定义的类定义比较规则。

一个类实现 Comparable 接口以后，必须要在类内部实现它的 CompareTo 方法。可我们有时候会有这样的需求：同一个对象在不同的使用场景下，可能会有不同的比较规则。因此，我们将变化的比较规则单独抽出来，这便有了 Comparator。

3 逐步实现二叉搜索树

3.1 二叉搜索树的属性

对于一棵树来说，我们首先需要定义树节点。二叉搜索树的节点除了包含节点元素本身，同时也需要指向左右孩子节点的指针，为了后续更方便地实现一些算法，我们也需要一个指针指向该节点的父亲节点。代码实现如下：

// 这里我们将节点类定义为二叉搜索树的内部类
public class Node<E>{
	public E element;
	public Node<E> parent;
	public Node<E> left;
	public Node<E> right;

	public Node(E element, Node<E> parent){
		this(element, parent, null, null);
	}
	
	public Node(E element, Node<E> parent, Node<E> left, Node<E> right){
		this.parent = parent;
		this.element = element;
		this.left = left;
		this.right = right;
	}
}

完成树节点的定义后，我们可以定义二叉搜索树的属性成员了。首先我们需要一个根节点引入一棵二叉搜索树，同时，我们也需要一个变量 size 记录二叉搜索树的节点数量。

private Node<E> root;
private int size;

3.2 二叉搜索树如何添加、删除元素

3.2.1 添加元素

当整棵树为空时，我们直接将该节点赋给根节点 root 即可。树不为空时，我们需要比较元素的大小来寻找元素的添加位置，如果新节点的元素值比当前节点的元素值小，则往左孩子那边继续比较，否则，往右孩子那边继续比较。代码如下：

public void add(E element){
	// 首先我们需要保证传进来的 element 元素不为空
	ensureEleNotNull(element);
	
	// 如果根节点为空
	if(root == null){
		root = newNode;
		size++;
		return ;
	}
	
	int cmp = 0;
	Node<E> node = root;
	Node<E> parent = root;
	// 如果不为空，先找到对应的父节点
	while(node != null){
		parent = node;
		cmp = compare(node.element, element);	// 自定义比较函数, 见下文
		if(cmp > 0){
			node = node.right;
		}
		if(cmp < 0){
			node = node.left;
		}
	} 
	
	Node<E> newNode = new Node<>(element, parent);
	if(cmp > 0){
		parent.right = newNode;
	}else if(cmp < 0){
		parent.left = newNode;
	}
	size++;
}

// 查看元素是否为 null，如果是，则抛异常。
private void ensureEleNotNull(E element){
	if(element == null){
		throw new IllegalArgumentException("element is not be null !");
	}
}

3.2.1.1 compare(E obj1, E obj2) 方法的设计

对于上述代码中的 compare(E obj1, E obj2) ，我们既希望它可以使用 Comparator 中的 compare(E obj1, E obj2) ，也希望它可以使用 Comparable 中的 compareTo(E obj) 。也就是说，我们支持两种比较方式，给使用者更灵活的选择。但是在使用时只能选择其中一个比较规则，这里我们优先选择前者，即如果 Comparator 存在，则使用前者的 compare 方法，否则使用后者的 compareTo 方法 。

对于 Comparator，我们需要在外部定义一个比较器类实现其中的 compare 方法。与此同时，我们也需要给二叉搜索树的属性成员添加一个 Comparator 对象，并且添加对应的构造函数。

private Comparator<E> comparator;

public BinarySearchTree(Comparator<E> comparator){
	this.comparator = comparator;
}

public BinarySearchTree(){
	this(null);
}

对于 Comparale，我们需要将泛型 E extens Comparable，如下所示：

class BinaerSearchTree<E extends Comarable> {
	...
}

然后在对应的元素类内部实现 compareTo 方法即可。

最终 compare(E obj1, E obj2) 的实现如下：

private int compare(E obj1, E obj2){
	// 如果 comparator 存在则使用 comparator.compare()，否则使用固定的 compareTo();
	if(comparator != null){
		return comparator.compare(obj1, obj2);
	}
	
	return obj1.compareTo(obj2);
}

3.2.2 删除元素

在二叉搜索树中，添加元素后默认会保持该树依旧是一棵二叉搜索树，可删除元素就不一定了。比如，将二叉搜索树的根节点删除，一棵完整的二叉搜索树会被拆成左右两棵子树（假设它的左右子树都不为空），这种情况下我们就需要寻找一个现存的节点替代被删除节点的位置，并保持该树依旧是一棵二叉搜索树。

我们将删除的节点分为三种类别：（1）左右子树为空的节点，即叶子节点；（2）只有一棵子树的节点；（3）左右子树都不为空的节点。三种节点被删除后有着各自不同的处理方式。

（1）叶子节点。叶子节点被删除后整棵树依旧是一棵二叉搜索树，我们只需要找到该叶子节点的父节点，并且判断它是属于父节点的左孩子还是右孩子。如果是左孩子，让父节点的左孩子为空，反之，右孩子为空。

if(node.left == null && node.right == null){
	Node<E> parent = node.parent;
	if(parent.left == node){
		parent.left = null;
	}else{
		parent.right = null;
	}
}

（2）只有一棵子树的节点。一样的，我们依旧需要找到该节点的父节点，如果被删除节点的左孩子不为空，那就让父节点的左孩子等于被删除节点的左孩子，反之，则是右孩子。这样我们便保证了该树依旧是一棵二叉搜索树。注意，这里我们需要维护孩子节点的父亲节点。

Node<E> child = null;
Node<E> parent = node.parent;
if(node.left == null && node.right != null){
	child = node.left;
	child.parent = parent;
	parent.left = child;
}else if(node.right == null && node.left != null){
	child = node.right;
	child.parent = parent;
	parent.right = child;
}

（3）左右子树都不为空的节点。这种情况下，替代节点有两种选择。我们可以选择左子树中元素值最大的节点，也可以选择右子树中元素值最小的节点。

3.2.2.1 前驱节点与后继节点

其中，左子树中元素最大的节点是删除节点的前驱节点（中序遍历中该节点的前一个节点），右子树中最小的节点是删除节点的后继节点（中序遍历中该节点的后一个节点）。因此，我们首先需要方法分别获取删除节点的前驱节点和后继节点。

如何获取一个节点的前驱节点呢？我们先看一下前驱节点的定义：中序遍历中该节点的前一个节点。从这个定义中我们需要明白，二叉搜索树的中序遍历是一个从小到大的排序，因此，某一个节点的前驱节点便是该节点前面所有节点中值最大的节点。

如果该节点有左子树，那前驱节点便是左子树中的最大值，即左子树中最右边的节点。

if(node.left != null){

	Node<E> resNode = node.left;
	while(resNode.right != null){
		resNode = resNode.right;
	}
	return resNode;
}

如果该节点为叶子节点或者只有右子树，我们只需要沿着该节点的父亲节点一直往上寻找。当某一个节点不是它父亲节点的左孩子时，该节点的父亲节点便是我们要找的前驱节点。这里大家可以画二叉搜索树的示意图，以寻找叶子节点的前驱节点为例，这样会有更直观的理解。

if(node.left == null){

	Node<E> parentNode = node.parent;
	Node<E> childNode = node;
	while(parentNode != null && parentNode.right != childNode){
		childNode = parentNode;
		parentNode = parentNode.parent;
	}
	return parentNode;
}

同理，后继节点也一样，只需要将上述代码的 left 换成 right，right 换成 left 即可。

综上所述，删除节点的代码如下：

public void remove(E element) {
        // 确保该元素在二叉搜索树中
        Node<E> node = getNode(element);

        // node 不在二叉搜索树中
        if(node == null){
            return;
        }

        size--;

        // 有两个孩子，此时 node 指向是被删除的节点
        if(node.hasTwoChildren()){
            Node<E> s = succssor(node);
            node.element = s.element;
            node = s;
        }

        // 被删除节点要么是叶子节点，要么是度为 1 的节点。如果不是叶子节点，那么就需要找它的孩子代替。
        Node<E> replacement = node.left != null ? node.left : node.right;

        if(replacement != null){    // 此时被替代节点是叶子节点
            // 修改父节点
            replacement.parent = node.parent;

            if(node.parent == null){    // 根节点
                root = replacement;
            }else if(node == node.parent.left){  // 左孩子
                node.parent.left = replacement;
            }else{  // 右孩子
                node.parent.right = replacement;
            }

        }else if(node.parent == null){  // node 是叶子节点并且是根节点

            root = null;
            
        }else{  // node 是叶子节点但不是根节点

            if(node == node.parent.left){
                node.parent.left = null;
            }else{
                node.parent.right = null;
            }
        }
}

private Node<E> getNode(E element){

	ensureEleNotNull(element);
	
	Node node = root;
	while(node != null){
		if(compare(element, node.element) > 0){
			node = node.right;	
		}else if(compare(element, node.element) < 0){
			node = node.left;
		}else{
			return node;
		}
	}
	return null;
}

3.3 二叉搜索树如何遍历元素

所谓遍历(Traversal)，是指沿着某条搜索路线，依次对树（或图）中每个节点均做一次访问。访问结点所做的操作依赖于具体的应用问题， 具体的访问操作可能是检查节点的值、更新节点的值等。不同的遍历方式，其访问节点的顺序是不一样的。（百度百科）

二叉搜索树的遍历方式通常分为以下四种：前序遍历、中序遍历、后序遍历、层序遍历。

3.3.1 (前中后层) 序遍历的访问顺序

前序遍历、中序遍历以及后序遍历意味着不同的节点访问顺序，”前中后“ 是相对于根节点而言的。

前序遍历先访问根节点，再访问左子树，然后访问右子树。

中序遍历先访问根节点的左子树，再访问根节点，然后访问根节点的右子树。

后序遍历先访问根节点的左子树，再访问根节点的右子树，然后访问根节点。

层序遍历和其名字一样，遍历顺序从根节点开始，从左到右一层一层往下访问。

注意，理解这三种遍历方式需要明白二叉树本身是递归结构，即任何一个节点的左子树或者右子树都是二叉树，遍历的时候遇到空节点需要延原路返回。

3.3.2 定义访问操作

除了上述的访问顺序以外，更重要的是我们怎么操作被访问元素。书上通常是将元素值打印出来，但在不同的应用场景中，操作可能是会改变的，比如我们想让每个节点的元素值加 1。因此，我们定义一个访问器接口声明一种访问的能力，这样我们可以根据自己的应用需求实现不同的 visit 逻辑。比如：

public interface VisitorPlusOne<E>{
	int visit(E element);
}

假设节点是 Integer 对象，我们想让每一个节点的元素值加 1，我们可以实现一个访问类：

public class VisitPlusOne<E> implements VisitorPlusOne<E>{
	@Overide
	public int visit(E element){
		return element + 1;
	}
}

当访问到某一个节点时，拿前序遍历举例，我们可以这么做：

public void preOrder(VisitPlusOne<E> visitor){
       if(visitor == null){
       	return ;
       }
       
       preOrder(root, visitor);
   }

private void preOrder(Node<E> root, VisitPlusOne<E> visitor){
    if(root == null){
	  return ;
	}

    root.element = visitor.visit(root.element);		// 访问元素的操作
    preOrder(root.left, visitor);
    preOrder(root.right, visitor);
  }

3.3.3 遍历的实现代码

关于遍历的具体代码，大家可以参考 Leetcode 的题，建议大家用不同的方法动手实现一遍。

二叉树的前序遍历（LeetCode）
二叉树的中序遍历（LeetCode）
二叉树的后序遍历（LeetCode）
二叉树的层序遍历（LeetCode）

递归的方式就不写了（相信大家都会写），这里用非递归的方式实现这四种遍历方式，访问方式依旧使用上述的 VisitPlusOne。非递归的实现方式有多种，大家可以多参考 Leetcode 的解答区。

3.3.3.1 前序遍历

我们需要借助栈实现前序遍历：

public void preOrder(VisitPlusOne<E> visitor){
	if(root == null){
		return;
	}
	
	LinkedList<Node> stack= new LinkedList<>();		// 这里用链表模拟栈
	Node<E> outNode = root;
	stack.add(outNode);
	while(!stack.isEmpty()){
	
		outNode = stack.pollLast();
		outNode.element = visitor.visit(outNode.element);		
		
		if(outNode.right != null){
			stack.add(outNode.right);
		}

		if(outNode.left != null){
			stack.add(outNode.left);
		}
	}
}

3.3.3.2 中序遍历

一样的，中序遍历也需要栈的协助：

public void inOrder(VisitPlusOne<E> visitor){
	if(root == null){
		return;
	}
	
	LinkedList<Node> stack= new LinkedList<>(); 
	Node<E> cur = root;
	Node<E> outNode = null;
	stack.add(cur);
	while(!stack.isEmpty()){
	
		while(cur.left != null){
			stack.add(cur.left);
			cur = cur.left;
		}
		
		outNode = stack.pollLast();
		outNode.element = visitor.visit(outNode.element);
		if(cur.right != null){
			cur = cur.right;
			stack.add(cur);
		}
	}
}

3.3.3.3 后序遍历

后序遍历也需要栈的协助（后序遍历用非递归实现在我看来是最麻烦的）：

public void postOrder(VisitPlusOne<E> visitor){
	if(root == null){
		return;
	}
	
	LinkedList<Node> stack= new LinkedList<>(); 
	Node<E> cur = root;		// 记录当前遍历到的节点
	Node<E> lastVisited = null;		// 标记上一次访问过的节点
	
 	while(!stack.isEmpty() || cur != null){		// cur != null 仅仅是为了第一次能进入 while 循环 
        // 一直往左
	    while(cur != null){
	        stack.add(cur);
	        cur = cur.left;
	    }

        cur = stack.pollLast();
        // 查看右子树能不能访问不能访问的话就让元素继续出队列
        if(cur.right == null || lastVisit == cur.right){
            lastVisit = cur;
            cur.element = visitor.visit(cur.element);
            cur = null;		// 不能访问的话则需要元素继续出栈，cur 置为空是为了跳过上面的 while 循环
        }else{
        	// 右子树能访问的话就让根节点回去，然后深入访问右子树
            stack.add(cur);
            cur = cur.right;
        }
   }
}

3.3.3.4 层序遍历

层序遍历需要队列的协助：

public void inOrder(VisitPlusOne<E> visitor){
	if(root == null){
		return;
	}
	
	LinkedList<Node> queue= new LinkedList<>();		// 这里用链表模拟队列
	queue.add(root);

	Node<E> outNode = null;
	while(!queue.isEmpty()){
	
		outNode = queue.pollFirst();
		outNode.element = visitor.visit(outNode.element);		
		
		if(outNode.left != null){
			queue.add(outNode.left);
		}
		
		if(outNode.right != null){
			queue.add(outNode.right);
		}
	}
}

4 总结

回到刚开始我们提出的问题，“二叉搜索树是如何将查找的时间复杂度降为 O(logn) 的呢？”。如果二叉搜索树按我们刚刚那样添加元素或者删除元素，查找的时间复杂度不一定是 O(logn)。极端情况下，二叉搜索树还有可能会退化成链表，此时查找的时间复杂度依旧是 O(n)。比如我们按从小到大（或从大到小）的顺序添加元素，二叉搜索树的所有节点都只有右子树（左子树）不为空。

这种情况并不是我们想看到的，如何解决这个问题呢？我们需要在添加删除元素后改进当前的二叉搜索树，尽量让每个节点的左右孩子都不为空。前人已经帮我们想过这个问题，并且提出了更棒的二叉搜索树 - 平衡二叉树。什么是平衡二叉树？详情请见文章：数据结构系列：平衡二叉树之 AVL 树。