一、二叉树
在了解二分搜索树之前我们先来了解二叉树。
二叉树是一种动态数据结构。
二叉树的定义：头节点e、左子节点、右子节点
1.二叉树具有唯一根节点。上图最上面的节点28就是根节点。
2.二叉树中每个节点最多有两个子节点。
3.没有子节点的节点称为叶子节点。
4.每个节点最多只有一个父节点。根节点没有父节点。
5.二叉树的每个节点可以有一个子节点或者两个子节点。
二叉树的性质：
1.二叉树具有天然的递归结构
2.每个节点的左子树、右子树也都是二叉树
3.二叉树不一定是“满”的，即使一个节点也是二叉树，null也是一个二叉树。例如：
二、二分搜索树
二分搜索树也是二叉树。
二分搜索树的每个节点的值：
- 大于其左子树的所有节点的值。
- 小于其右子树的所有节点的值。
每一棵子树也是二分搜索树。
存储的元素必须有可比较性。
//Comparable:元素要具有可比较性
public class BST<E extends Comparable<E>> {
//声明私有节点类
private class Node {
//元素e
public E e;
//左子节点、右子节点
public Node left, right;
//存放用户传进来的节点信息
public Node(E e) {
this.e = e;
//初始化左右子节点为null
left = null;
right = null;
}
}
//根节点
private Node root;
//声明二分搜索树有多少个元素
private int size;
public BST(){
//初始化根节点为null，null也是一种二叉树
root = null;
//初始化size为0
size = 0;
}
public int size(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
}
1.向二分搜索树添加元素
添加的元素从根节点出发进行判断然后选择它的位置。如果添加的元素已经是在二分搜索树中存在了，那么当遍历判断到该存在的位置时，就不再进行下一步判断了，就相当于覆盖了此元素或者还是保持原来此元素不变。二分搜索树不包含重复的元素。
不过想实现可以重复元素的二分搜索树需要用户自己定义节点让左子树小于等于父节点，右子树大于等于父节点。
二分搜索树添加元素的非递归写法，与链表的很像。如下添加28节点的蓝色路线：
在二分搜索树方面，递归比非递归实现简单。
// 向二分搜索树中添加新的元素e
public void add(E e){
//如果根节点为null
if(root == null){
//则新建一个父节点
root = new Node(e);
//维护size变量
size ++;
}else {
//如果不为空，则从根节点开始进行插入元素
add(root, e);
}
}
// 向以node为根的二分搜索树中插入元素e，递归算法
private void add(Node node, E e){
//判断要插入的元素e是已经存在与二分搜索树中
if(e.equals(node.e)) {
//有则直接return出来
return;
//否则，如果要添加的元素小于node.e的话，并且左子节点为空
}else if(e.compareTo(node.e) < 0 && node.left == null){
//new一个新的左子节点
node.left = new Node(e);
size ++;
return;
//再否则，如果要添加的元素大于node.e的话，并且右子节点为空
}else if(e.compareTo(node.e) > 0 && node.right == null){
//new一个新的右子节点
node.right = new Node(e);
size ++;
return;
}
//递归调用
//如果添加元素e比父节点小
if(e.compareTo(node.e) < 0) {
//重新调用add(Node node, E e)方法进行判断
add(node.left, e);
}else { //e.compareTo(node.e) > 0
add(node.right, e);
}
}改进添加操作：深入理解递归终止条件。
// 向二分搜索树中添加新的元素e
public void add(E e){
//如果root为空，则向root添加元素
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的左子树添加上这次变化的e
//如果add(node.left, e)中的node.left为空，则会返回一个新的节点
node.left = add(node.left, e);
}else if(e.compareTo(node.e) > 0) {
node.right = add(node.right, e);
}
//返回出node节点
return node;
}2.二分搜索树的查询操作
// 看二分搜索树中是否包含元素e
public boolean contains(E e){
//从root开始查看整个树包不包括元素e
return contains(root, e);
}
// 看以node为根的二分搜索树中是否包含元素e, 递归算法
//传入节点node，和一个待查询的元素e
private boolean contains(Node node, E e){
if(node == null) {
//如果树为空，直接返回false
return false;
}
if(e.compareTo(node.e) == 0) {
//如果等于要查找的元素e，则返回true
return true;
//如果要操作的元素e小于节点node，则递归返回从左节点开始重新进行查找判断操作
} else if(e.compareTo(node.e) < 0) {
return contains(node.left, e);
} else { // e.compareTo(node.e) > 0
return contains(node.right, e);
}
}3.二分搜索树的遍历操作（深度优先遍历）
遍历操作就是把所有节点都访问一遍。访问的原因和业务有关。对于遍历操作，两棵子树都要顾及。
前序遍历：先访问该节点再访问其左右子节点
// 二分搜索树的前序遍历
public void preOrder(){
//用户调用有参数的preOrder方法，传入Node参数root
preOrder(root);
}
// 前序遍历以node为根的二分搜索树, 递归算法
private void preOrder(Node node){
//如果没有节点则直接返回
if(node == null) {
return;
}
//打印下树节点元素
System.out.println(node.e);
//遍历左子树的所有节点
preOrder(node.left);
//遍历右子树的所有节点
preOrder(node.right);
}
@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){
//如果节点node为空
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);
}
//深度打印，调用toString中的递归
private String generateDepthString(int depth){
StringBuilder res = new StringBuilder();
//遍历深度
for(int i = 0 ; i < depth ; i ++) {
res.append("--");
}
return res.toString();
}测试类：
public class Main {
public static void main(String[] args) {
BST<Integer> bst = new BST<>();
int[] nums = {5, 3, 6, 8, 4, 2};
for(int num: nums)
bst.add(num);
/////////////////
// 5 //
// / \ //
// 3 6 //
// / \ \ //
// 2 4 8 //
/////////////////
bst.preOrder();
System.out.println();
System.out.println(bst);
}
}打印结果： 
中序遍历：先访问节点的左子树，再访问该节点，然后访问该节点的右子树
// 二分搜索树的中序遍历
public void inOrder(){
//用户调用有参inOrder()方法传入Node参数值root
inOrder(root);
}
// 中序遍历以node为根的二分搜索树, 递归算法
private void inOrder(Node node){
if(node == null) {
return;
}
//先访问左子树
inOrder(node.left);
//然后访问该节点
System.out.println(node.e);
//接着访问右子树
inOrder(node.right);
}中序遍历的结果按顺序排序的。
后序遍历：先访问左子树，再访问右子树，接着访问中间的节点
// 二分搜索树的后序遍历
public void postOrder(){
postOrder(root);
}
// 后序遍历以node为根的二分搜索树, 递归算法
private void postOrder(Node node){
if(node == null) {
return;
}
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}后续遍历应用：为二分搜索树释放内存。
下面分析三种遍历：
前序遍历：首先访问一下中间该节点元素，然后接着访问左节点元素，直到叶子节点元素，此时被访问的节点称为被访问到的节点，即成功访问到了该节点，接着访问叶子节点中的左节点元素，没有左节点元素，再访问该叶子节点元素，再访问该叶子节点的右节点元素，没有右节点元素，接着回到该叶子节点元素的父节点元素，接着访问该节点元素的右节点元素，依次类推，直到回到根节点右节点元素为止。
中序遍历：和前序遍历的方式一样，只不过访问到该元素的中间位置时，才真正的称访问了该元素。
后序遍历：和前序遍历的方式一样，只不过访问到该元素的右节点位置时，才真正的称访问了该元素。
4.二分搜索树前序遍历的非递归写法
利用栈结构来实现。
首先把根节点放入栈中，再把28拿出来。此时称28被访问到了。访问了根节点之后，接着访问子节点，先把右节点压入栈，然后是左节点，因为栈是后入先出的，依次类推，直到最右一个节点出栈为止。
1.
2. 
3. 
由于13是叶子节点元素，所以接着访问16的右节点元素，接着22出栈，依次类推。最后发现利用栈实现的前序遍历和使用递归遍历结果是一样的。
// 二分搜索树的非递归前序遍历
public void preOrderNR(){
if(root == null) {
return;
}
Stack<Node> stack = new Stack<>();
//向栈中添加节点元素root
stack.push(root);
//只要栈不为空
while(!stack.isEmpty()){
//定义当前访问的节点，把访问到的节点从栈顶中拿出来
Node cur = stack.pop();
//打印拿出来的元素
System.out.println(cur.e);
//访问该节点的右子树
if(cur.right != null) {
//先将右子树压入栈中
stack.push(cur.right);
}
if(cur.left != null) {
stack.push(cur.left);
}
}
}二分搜索树的非递归实现，比递归实现复杂很多。此时我们的遍历操作完成了。
5.二分搜索树的层序遍历（广度优先遍历）
利用队列来模拟广度优先遍历的操作。先进先出。需要注意的是，元素是从队尾入队的。
0层：28从队尾入队，接着出队，此时0层访问完了。
1层：从左边开始，16先入队，接着30入队，然后16先入队，接着再把节点16的子节点13、22入队，16先从队首出队，接着30出队，接着节点30的子节点29、42入队。此时1层访问完毕。
2层：依次类推。直到每一层遍历完，出队完，则称该树的节点都访问完毕。
// 二分搜索树的层序遍历
public void levelOrder(){
if(root == null) {
return;
}
//链表队列
Queue<Node> q = new LinkedList<>();
//向队列添加节点元素
q.add(root);
//如果队列不为空
while(!q.isEmpty()){
//把入队后的当前节点取出
Node cur = q.remove();
System.out.println(cur.e);
if(cur.left != null) {
q.add(cur.left);
}
if(cur.right != null) {
q.add(cur.right);
}
}
}广度优先遍历能更快的找到问题的解，常用于算法设计中——最短路径。
学习数据结构和算法不是单纯的记忆，想要灵活应用或者更加深刻的理解，需要刻意的找出不同方法之间的差异，及使用于什么样的场合，才能准确的使用数据结构。
6.删除节点
删除最大、最小值。
一直向左遍历，直到最后一个左节点元素，该元素就是最小元素，向右遍历直到最后一个右节点元素，该元素为最大元素。
// 寻找二分搜索树的最小元素
public E minimum(){
if(size == 0) {
throw new IllegalArgumentException("BST is empty");
}
//初始调用有参方法minimum
Node minNode = minimum(root);
//返回该节点的元素
return minNode.e;
}
// 返回以node为根的二分搜索树的最小值所在的节点
private Node minimum(Node node){
//一直向左走，如果走到为空了，则表示该节点元素为mininum
if( node.left == null ) {
return node;
}
//否则返回递归该节点的子节点到此方法中，进行下一步判断
return minimum(node.left);
}
// 寻找二分搜索树的最大元素
public E maximum(){
if(size == 0) {
throw new IllegalArgumentException("BST is empty");
}
return maximum(root).e;
}
// 返回以node为根的二分搜索树的最大值所在的节点
private Node maximum(Node node){
if( node.right == null ) {
return node;
}
return maximum(node.right);
}
此时已经能查找到最小最大值了，下面分析怎么在二分搜索树中删除一个元素的操作。
删除最小值：
1对于最小值叶子节点13，直接删除即可。
2.接着继续删除最小值的叶子节点15。
此时的22就称为了最左节点元素即最小值。把它给删除的时候需要注意，该节点下还有子树，此时需要将该节点的子树连接到该节点的父节点即可。
删除最大值也是如此。
// 从二分搜索树中删除最小值所在节点, 返回最小值
public E removeMin(){
//调用minimum()方法来判断元素ret
E ret = minimum();
//从root节点开始尝试判断该元素是否为最小值节点并删除
root = removeMin(root);
return ret;
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){
//如果当前节点不能再向左走
if(node.left == null){
//定义右子树来保持该左节点元素的右子树
Node rightNode = node.right;
//保存完毕后，就可以让该节点的右节点变为null了
node.right = null;
//删除掉一个元素，size--
size --;
//返回一个新的根(node.right)
return rightNode;
}
//如果根节点的做节点不为空
//则让node.left等于递归调用removeMin()方法返回来的新的node的左子树
node.left = removeMin(node.left);
//将原来的node返回回去，就以此次操作为例，
//返回的node会被传进node.left = removeMin(node.left)中emoveMin(node.left)
//中的node里
return node;
}
// 从二分搜索树中删除最大值所在节点
public E removeMax(){
E ret = maximum();
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;
}删除任意一个元素。
下面分析此操作的情况：
【1】删除只有左子树的节点：和前面介绍的删除操作逻辑一样。
【2】删除只有右子树的节点：和前面介绍的删除操作逻辑一样。
【3】删除一个左右都有子树的节点:
<1> 后继操作：找到该节点的右子树中最小的节点59,接着让59这个子节点覆盖到58的位置。
// 从二分搜索树中删除元素为e的节点
public void remove(E e){
//递归函数：remove,初试调用为root位置的节点e
root = remove(root, e);
}
// 删除掉以node为根的二分搜索树中值为e的节点, 递归算法
// 返回删除节点后新的二分搜索树的根
private Node remove(Node node, E e){
if( node == null ) {
return null;
}
//如果要删除的元素e小于当前节点的元素e
if( e.compareTo(node.e) < 0 ){
//递归调用此方法从node.left这个位置去尝试删除元素e
//并将尝试删除的结果赋值给当前的node.left
node.left = remove(node.left , e);
//返回当前node
return node;
}else if(e.compareTo(node.e) > 0 ){
node.right = remove(node.right, e);
return node;
} else { // 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;
}
// 待删除节点左右子树均不为空的情况
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
// 用这个节点顶替待删除节点的位置
Node successor = minimum(node.right);
successor.right = removeMin(node.right);
successor.left = node.left;
//让要删除的节点node与当前二分搜索树脱离关系
node.left = node.right = null;
//返回原来位置上新的元素值
return successor;
}
}<2>前驱操作：找到在待删除元素的左子树中的最大值，然后替换到待删除位置上的元素。
这里不再做实现，如果有兴趣，可以自己尝试着去实现它。
关于二分搜索树的其他问题：
1.获取节点的前驱predecessor和后继节点successor。
2.寻找比指定节点元素小的所有节点元素中最大的数floor，寻找比指定节点元素大的所有节点元素中最小的元素ceil。
3.rank：查找指定元素的排名，需要维护size变量，或者维护深度值。
4.select：查找指定排名的那个元素是谁，需要维护size变量，或者维护深度值。
5.支持重复元素的二分搜索树：把条件定为小于等于和大于等于或者定义作用域，记录此节点有多少个元素。
