在讨论二分搜素树之前，我们先来讨论一下什么是二叉树
1.二叉树
二叉树和链表一样是一种动态的数据结构
a.二叉树：具有唯一的根节点
b.二叉树：每一个节点的左右子树也是二叉树，叶子节点的左右孩子都为null
c.二叉树不一定是满的
d.一个节点也是二叉树
e.null 也是二叉树，也可以看成是一个链表
2.二分搜索树 Binary Search Tree
性质：
a. 二分搜索树是二叉树
b.二分搜索树的每一个节点的值：
大于其左子树的所有节点的值
小于其右子树的所有节点的值
c.每一颗子树也是二分搜索树
e.存储的元素必须具有可比较性（二分搜索树的一个缺点）
3.二分搜索树的操作
a.二分搜索树添加新元素
我们的二分搜索树不包含重复元素，如果需要包含重复元素的话只需要定义：左子树小于等于节点；或者右子树大于等于节点既可以，我们之前实现的数组和链表是包含重复元素的；其实关于是否包含重复元素，主要要从实际的应用场景来看。
二分搜索树添加元素的非递归写法，和链表很像，由于递归实现比非递归实现要简单，我们这里使用递归实现二分搜索树
b.二分搜索树的遍历（遍历就是把所有节点都访问一遍）
c.二分搜索树的递归操作
d.二分搜索树的前序遍历（先访问该节点，再访问左右子树）
e.二分搜索树的中序遍历（先访问左子树，再访问该节点，再访问右子树）
中序遍历对于二分搜索树，是按大小排序的。
f.二分搜索树的后序遍历
4.二分搜索树前序遍历的非递归写法
我们需要使用栈作为辅助来进行遍历
二分搜索树遍历的非递归实现比递归实现的复杂很多，中序遍历和后序遍历的非递归实现更加复杂
5.二分搜索树的层序遍历（广度优先遍历）
实现：我们可以使用队列来实现广度优先进行遍历
广度优先遍历的意义：
a.更快的找到问题的解
b.常用于算法设计中，最短路径
c.图中深度优先遍历和广度优先遍历
6.二分搜索树的删除操作
我们从删除最大，最小值开始（删除任意值，我们可以复用这个方法）
怎样找到最大最小值：向左走走不动了，就是最小值；向右走走不动了，就是最大值。
讨论删除最小值的情况（2种）：
第一种情况：删除的最小值没有右子树
第二种情况：删除的最小值没有右子树
删除最大值也是同样的道理。
讨论删除任意节点的情况：
第一种情况：删除只有左孩子的节点
第二种情况：删除只有右孩子的节点，与只有左孩子的节点类似
第三种情况：删除左右都有孩子的节点
1962年，Hibbard提出- Hibbard Deletion
比如删除58，找一个节点替代58的位置，怎么找呢？找距离58最近的，比58还要大的节点（这个节点就是右子树中值最小的节点）
在d 的右子树中删除，最小值
或者使用d的前驱，也是可以的
代码实现：
import java.util.Stack;
import java.util.LinkedList;
import java.util.Queue;
// 我们的二分搜索树，存储的数据有一定的局限性,要具有可比较性
// 满足接口Comparable
public class BST <E extends Comparable<E>>{
//1.申明节点类
private class Node{
public E e;
public Node left,right;
// 我们这里只构建一个节点类
public Node(E e){
this.e = e;
left = null;
right = null;
}
}
// 2. 定义根节点
private Node root;
private int size;
public BST(){
root = null;
size = 0;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
// 3. 二分搜索树添加新元素，对于重复元素，我们不对其进行操作，这里非递归写法和链表很像，只是需要跟左右孩子比较
// 向二分搜索树中添加新的元素
public void add(E e){
root = add(root, e);
}
// 改进递归函数,向以node为根的二分搜索树中插入元素e，递归算法
// 返回插入新节点后二分搜索树的根
private Node add(Node node, E e){
if(node == null){
size ++;
return new Node(e);
}
if(e.compareTo(node.e) <0)
node.left = add(node.left,e);
else if(e.compareTo(node.e) >0)
node.right = add(node.right,e);
return node;
}
// 看二分搜索树中是否包含元素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 //e.compareTo(node.e) > 0
return contains(node.right,e);
}
// 5.二分搜素树的前序遍历
public void preOrder(){
preOrder(root);
}
// 前序列遍历以node为根的二分搜素树，递归算法
private void preOrder(Node node){
if(node != null){
System.out.print(node.e+" ");
preOrder(node.left);
preOrder(node.right);
}
}
// 前序遍历的非递归实现
public void preOrderNR(){
Stack<Node> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
Node cur = stack.pop();
System.out.print(cur.e+" ");
if(cur.right !=null)
stack.push(cur.right);
if(cur.left !=null)
stack.push(cur.left);
}
}
// 二分搜索树的中序遍历
public void inOrder(){
inOrder(root);
}
private void inOrder(Node node){
if(node == null)
return;
inOrder(node.left);
System.out.print(node.e+" ");
inOrder(node.right);
}
// 二分搜索树的后序遍历
public void postOrder(){
postOrder(root);
}
private void postOrder(Node node){
if(node == null)
return;
postOrder(node.left);
postOrder(node.right);
System.out.print(node.e+" ");
}
// 这里的Queue 是一个接口，需要new 一个底层的数据结构
// 二分搜索树的层序遍历
public void levelOrder(){
Queue<Node> q = new LinkedList<>();
q.add(root);
while(!q.isEmpty()){
Node cur = q.remove();
System.out.print(cur.e+" ");
if(cur.left != null)
q.add(cur.left);
if(cur.right != null)
q.add(cur.right);
}
}
// 寻找二分搜索树的最小元素,相当于操作链表
public E mininum(){
if(size == 0)
throw new IllegalArgumentException("BST is empty!");
return minimum(root).e;
}
// 返回以node为根的二分搜索树的最小键值所在的节点
private Node minimum(Node node){
if(node.left == null)
return node;
return minimum(node.left);
}
public E maxinum(){
if(size == 0)
throw new IllegalArgumentException("BST is empty!");
return maxinum(root).e;
}
// 返回以node为根的二分搜索树的最小键值所在的节点
private Node maxinum(Node node){
if(node.right == null)
return node;
return minimum(node.right);
}
// 从二分搜索树中删除最小值所在的节点，返回最小值
public E removeMin(){
E ret = mininum();
root = removeMin(root);
return ret;
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// 从二分搜索树中删除最小值所在的节点，返回最小值
public E removeMax(){
E ret = maxinum();
root = removeMax(root);
return ret;
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMax(Node node){
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size --;
return leftNode;
}
node.right = removeMax(node.right);
return node;
}
// 从二分搜索树中删除元素为e的节点
public void remove(E e){
root = remove(root, 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{ // e == node.e
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;
}
// 待删除节点左右子树均不为空的情况
// 找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
// 用这个节点顶替待删除节点的位置
Node successor = minimum(node.right);
successor.right = removeMin(node.right);
size ++;
successor.left = node.left;
node.left = node.right = null;
size --;
return successor;
}
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
generateBSTString(root,0,res);
return res.toString();
}
// 生成node为根节点，深度为depth的描述二叉树的字符串,前序遍历的
private void generateBSTString(Node node,int depth,StringBuilder res){
if(node == null){
res.append(generateDepthString(depth)+"null\n");
return;
}
res.append(generateDepthString(depth) + node.e +"\n");
generateBSTString(node.left,depth+1,res);
generateBSTString(node.right,depth+1,res);
}
private String generateDepthString(int depth){
StringBuilder res = new StringBuilder();
for(int i=0; i<depth; i++)
res.append("--");
return res.toString();
}
}