数据结构 —— 二分搜索树
一、二分搜索的时间复杂度
二分搜索是一种高效的数据搜索，同时也可以高效的管理数据。高效就高效在它的结构，比如要找一个树中的数据，跟根一比，看大还是小，仔细想想，是真的很省时间，所以可以推断出它的时间复杂度一般在O(logn)（平衡）到O(n) （不平衡）之间，所以像Java底层源码使用的是红黑树，一种自平衡（AVL）的树，这样它的时间复杂度就是O(logn)了。
二、各种功能的实现
因为二分搜索一般是不包含重复元素的，所以要实现Comparable接口，（要用它的compareTo方法！）public class BST> 1、结点的定义，因为树是由结点构成的嘛
private class Node{
public E e;
public Node left;
public Node right;
public Node(E e){
this.e = e;
left = null;
right = null;
}
}
private Node root;
private int size;
public BST(){
root = null;
size = 0;
}
//增添,删除的时候要进行维护，即size ++; size--;
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}2、添加结点的方法
//向二分搜索树中添加新的结点
public void add(E e){
if(root == null) {
root = new Node(e);
size++;
}
//当根不为空的时候尝试从根节点开始插入新的元素
else
//注意这个add是private
add(root, e);
}
//在上面方法的基础上，向以node为根的二分搜索树中插入元素E，（递归）
private void add(Node node, E e){ //因为根是在不断变化的,node代表当前结点
//递归终止条件
if(e.equals(node.e)) //要插入的元素在二分搜索树中已经有了
return;
else if(e.compareTo(node.e) < 0 && node.left == null){
node.left = new Node(e); //把要加入的元素放进此空间
size ++;
return;
}
else if(e.compareTo(node.e) > 0 && node.right == null){
node.right = new Node(e); //左小< 右大>
size ++;
return;
}
//开始递归比较进行插入；
//且要插入的元素就是在空的地方的
if(e.compareTo(node.e) < 0)
add(node.left, e);
else
add(node.right, e);
}
我定义了一个公共的方法add和一个私有的方法add，后者是为前者服务的，前者是用来判断一切的开始 —— 根结点的，如果不存在那就在堆中new一个，如果存在那就好办了，直接进行私有递归方法的调用，为什么要再定义一个新的add()？因为如果要插入元素的话，基点肯定是当前的这个结点，但是还有元素e等着你添加啊，所以递归方法就有了两个参数，参数node代表当前结点，它是在不断变化的，e也是；所以这个私有add的意义就是向以node为根的二分搜索子树中插入元素e！剩余的就很简单，递归出口什么的都要有（见代码注释）。
3、查询结点的方法
//看当前树中是否包含元素e
public boolean contains(E e){
return contains(root, e);
}
//在上面方法的基础上，向以node为根的二分搜索树中查询元素E，（私有，递归）
private boolean contains(Node node, E e){
if(node == null)
return false;
if(e.compareTo(node.e) == 0)
return true;
else if(e.compareTo(node.e) < 0)
return contains(node.left, e);
else if(e.compareTo(node.e) > 0)
return contains(node.right, e);
else{
return false;
}
}它跟add也很相似，但只是结构相似，也是一个公共的，一个私有的，同样，公共的是针对根的，相对add()比较简单。
4、前序遍历
//非递归的前序遍历,(栈中的是结点，既然有结点那就是Node类)
public void preOrderNR(){
Stack stack = new Stack();
stack.push(root);
while(!stack.isEmpty()){
//cur就是当前要访问的结点，弹出，并输出
Node cur = stack.pop();
System.out.println(cur.e);
//在访问完cur结点后就去访问它对应的左右子树，并压入
if(cur.left != null)
stack.push(cur.left);
if(cur.right != null)
stack.push(cur.right);
}
} 递归的前中后都很简单，但是非递归的话只有前序来说比较简单，所以就用前序遍历了，非递归肯定是用栈做的，栈中的元素就是结点，还是先把root入栈再进行循环操作，在循环中要进行判空再去入栈。（见代码注解）
5、层序遍历
//层序遍历(队列）
public void levelOrder(){
/**
* 这种是错误的，因为Queue是个接口,不能直接被实例化
* ： Queue queue = new Queue<>();
*/
Queue queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){
Node cur = queue.remove();
System.out.println(cur.e);
if(cur.left != null)
queue.add(cur.left);
if(cur.right != null)
queue.add(cur.right);
}
} 层序遍历肯定用队列来做的，但是要注意Queue是个接口不能直接被实例化，所以只能先实例化它的子类。结构是类似上面的前序遍历的。cur是个结点，每次输出的是它的左(右)子树。
6、删除最小值并返回
//删除二分搜索树的最小结点,并返回最小值
public E removeMin(){
E ret = minmum(); //提前保存返回这个最小的元素
removeMin(root);
return ret;
}
private Node removeMin(Node node){
if(node.left == null){ //这个node就是要删的结点,node.left是它的左子树
Node rightNode; //rightNode用来保存当前结点的右子树（如果有的话）
rightNode = node.right;
node.right = null;
size --;
return rightNode; //修改以及删除之后一定要返回新的！（这时最小节点就被删除啦）
}
//然后一直向左进行递归，因为最小值是一定在最左边的，且这个最小值没有左子树
node.left = removeMin(node.left);
return node;
}最小元素肯定是在最左边那个没有左子树的结点了，而里面的rightNode的作用就是如果这个结点它有右子树的话，那就把右子树先保存在rightNode,然后再去删除那个结点，最后接上那个右子树（即返回rightNode），任何修改和删除一般情况下是要返回新的值的。
7、删除任意结点
先写一个找最小结点的方法，因为删除结点要用到它
//寻找二分搜索树的最小结点（最大结点同理）
public E minmum(){
if(size == 0)
throw new IllegalArgumentException("empty");
return minmum(root).e;
}
private Node minmum(Node node){
if(node.left == null)
return node;
return minmum(node.left);
}删除方法：
//删除任意一个元素
public void remove(E e){
root = remove(root, e);
}
//删除以node为根的二分搜索树中的 值为e的结点，（递归）
//删除后就返回相对于当前根（不一定是根节点）来说新的根
private Node remove(Node node, E e){
if(node == null)
return null;
if(e.compareTo(node.e) < 0){
node.left = remove(node.left, e);
return node;
}
else if(e.compareTo(node.e) > 0){
node.right = remove(node.right, e); //继续深入
return node;
}
else if(e.compareTo(node.e) == 0){ //定位到要删除的结点了
//结点的左子树为空时
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
//结点的右子树为空时
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size --;
return leftNode;
}
/**
* 左右子树都不为空时
* 先找到待删除结点右子树的最小结点，
* 再用这个结点顶替待删除结点的位置（不需要做size--操作）
*/
Node faitour = minmum(node.right);
faitour.right = removeMin(node.right);
faitour.left = node.left;
node.left = node.right = null;
return faitour;
}
else return null;
}首先先定位，一直递归找到要删除的元素，然后对他进行判断，有三种情况，有左无右，有右无左，有左有右，前两种在上面说过了，就是用rightNode(或者leftNode，得看是哪边)进行保存；麻烦的是既有左子树又有右子树，怎么改？有个科学家就想出来一个办法：左右子树都不为空时，先找到待删除结点右子树的最小结点，再用这个结点顶替待删除结点的位置。只需五行，见上图代码~ 上面说过的两个方法都要用，让这个结点继承删除这个结点后的右子树（说起来有点拗口）然后再让这个结点继承删除结点的左子树，再把删除结点的左右子树都置Null，这样它就永久被从树中去除了，最后不要忘，应返回删除后的结构（即返回这个faitour结点即可）。
三、运行结果
先贴上主函数：
package BST;
//关于树，首当其冲要做的操作的是跟root有关的，即根节点
//二分搜索树重要的是add()和contains()和remove()
import java.util.Random;
public class Main {
public static void main(String[] args) {
BST bst = new BST();
Random random = new Random();
int n = 10; //随机生成的元素个数
for(int i=0; i < n; i++)
bst.add(random.nextInt(10));
System.out.println(bst.removeMin());
System.out.println(bst.minmum());
System.out.println(bst.contains(random.nextInt(10)));
System.out.println("LevelOrder：");
bst.levelOrder();
System.out.println("PreOrder：");
bst.preOrderNR();
//再添加10个元素
for(int i=0; i < n; i++)
bst.add(random.nextInt(10));
System.out.println("After Add Element PreOrder：");
bst.preOrderNR();
bst.remove(5);
System.out.println("------");
System.out.println(bst.size());
}
}
运行后：
0
2
true
LevelOrder：
7
3
9
2
4
8
PreOrder：
7
9
8
3
4
2
After Add Element PreOrder：
7
9
8
3
4
6
5
2
0
1
------
9
确实没问题~
二叉搜索树确实是很快捷，我用上面这个代码把n设置为1000000，然后运行只需要1.5秒，也是很快的了。