二叉查找树的删除操作

先说一下如何删除二叉树查找树的节点吧。总共有三种情况

1.被删除的节点是叶子节点，这时候只要把这个节点删除，再把指向这个节点的父节点指针置为空就行

2.被删除的节点有左子树，或者有右子树，而且只有其中一个，那么只要把当前删除节点的父节点指向被删除节点的左子树或者右子树就行。

3.被删除的节点既有左子树而且又有右子树，这时候需要把左子树的最右边的节点或者右子树最左边的节点提到被删除节点的位置，为什么要这样呢，根据二叉查找树的性质，父节点的指针一定比所有左子树的节点值大而且比右子树的节点的值小，为了删除父节点不破坏二叉查找树的平衡性，应当把左子树最大的节点或者右子树最小的节点放在父节点的位置，这样的话才能维护二叉查找树的平衡性。（我是找的右子树的最小节点）

二叉树的删除可以算是二叉树最为复杂的操作，删除的时候要考虑到很多种情况：
1.被删除的节点是叶子节点
2.被删除的节点只有左孩子节点
3.被删除的节点只有右孩子节点
4.被删除的有两个孩子节点

所以在删除的时候，这4种情况都必须考虑进去，并且这4中情况之下，还会有细的划分，下面就细说怎么删除。

查找操作：

在二叉树中想要删除一个节点，首先需要找到这个节点，由于二叉树在插入节点的时候会遵循一个原则，就是利用节点的值来判断
节点将被插入的位置（或者给节点加一个key，用key来判断）。从根节点开始往下走，比当前节点小（或等于）的会被插入到
当前节点的左边，比当前节点大的会被插入到当前节点的右边。所以，根据根据二叉树的插入规则来找出即将被删除的节点。

代码如下;也就是二叉查找树的查找功能：

 1 //保存当前节点
 2         Node parent=root;//保存当前节点父节点
 3         boolean isLeft=true;//记录是否是左几点
 4         //定位到将被删除的节点 
 5         while(key!=curr.key){
 6             if(key<=curr.key){
 7                 isLeft=true;//经过左节点
 8                 if(curr.left!=null){
 9                     parent=curr;
10                     curr=curr.left;
11                 }
12             }else{
13                 isLeft=false;//经过右节点
14                 if(curr.right!=null){
15                     parent=curr;
16                     curr=curr.right;
17                 }
18             }
19             if(curr==null){
20                 return false;
21             }
22 }

代码说明：

在这段代码中，首先定义了两个引用，一个用来代表当前节点，一个用来代表当前节点的父节点，然后进入一个while循环，
循环里，首先会根据key的比较来决定该往左走还是往右走，如果往左走，就说明当前节点是它父节点的左孩子了，然后把
ifLeft设置为true，如果往右走，同理就把isLeft设置为false（isLeft在后面会被用到）。现在，往下走得方向
已经确定了，然后该就判断所经过的节点（即当前节点）是否为空，如果该节点的左右都为空，就说明你要删的节点没有找到，程序
将会返回false。如果如果当前节点左孩子不为空，就把当前节点等于它的左孩子，相当于又往下走了一步。正个寻找的过程，就是
不停的根据值判断，不停的往下走，直到满足条件，循环停止。这时，当前节点就保存的是即将被删除节点的引用，并且还知道被删除的
父节点是谁，被删除节点是它父节点的哪边的孩纸都知道。
找到了被删除的节点，下面就来看，要怎么删除它。

真正的删除操作：

1.如果被删除的节点是叶子节点，用代码表示就是

1 if(curr.left==null&&curr.right==null){
2             if(curr==root){
3                 root=null;
4             }else if(isLeft){
5                 parent.left=null;
6             }else{
7                 parent.right=null;
8             }
9         }

可以看出，情况又被细分了三种，当被删除节点即是叶子节点又是根节点，这是树中就只有一个根节点了，就直接删除
下面两种是判断的是，当前被删除节点是其父节点哪边的节点。

2.被删除的节点只有左孩子节点

1 if(curr.right==null){
2             if(curr==root){
3                 root=root.left;
4             }else if(isLeft){
5                 parent.left=curr.left;
6             }else{
7                 parent.right=curr.left;
8             }
9         }

当被删除的节点只有一个孩子时，就只需要用它的孩子节点，把它自己给替换下去。具体的还是跟上面一样，需要分三种情况
来考虑，如果是根节点，就直接把根节点指向根节点的左孩子，这样一来，原来的根节点就无法访问到，会被虚拟机自动回收掉。
同理下面也一样。

3.被删除的节点只有右孩子节点，这种情况跟第二种情况类似

1 if(curr.left==null){
2             if(curr==root){
3                 root=root.right;
4             }else if(isLeft){
5                 parent.left=curr.right;
6             }else{
7                 parent.right=curr.right;
8             }
9         }

4.被删除的有两个孩子节点，这种情况最复杂，因为要考虑到删除之后顺序不能乱。

所以这种类型的节点要删除，如果直接删，真个树的大小顺序就乱了，所以需要考虑，在树中找到一个合适的节点来把这个节点
给替换掉，用这种方法来保持整个数的稳定。所以又一个问题又来了了，该找哪个节点来替换它？结论是，需要在树中找出所有比
被删除节点的值大的所有数，并在这些数中找出一个最小的数来。听起来很拗，如果把它用图形来描述的话，就是，从被删除的节点出发
经过它的右节点，然后右节点最左边的叶子节点就是我们要找的，它有一个专业名词叫中序后继节点。下面专门来写一个方法来找它：

 1  public Node getSuccessor(Node delNode){  //参数为被删除的节点
 2             //定义一个当前节点的引用，直接让往下走一步，走到被删除节点的右节点
 3             Node curr=delNode.right; 
 4             Node successor=curr;  //用来指向中级后续节点
 5             Node sucParent=null; //用来指向中级后续节点的父节点
 6             while(curr!=null){  
 7                 sucParent=successor;
 8                 successor=curr;
 9                 curr=curr.left;
10             }
11             //循环停止，中级后续节点被找出
12             if(successor!=delNode.right){
13                 //将后继节点的子节点（只可能有右节点）替补到后继节点的位置上
14                 sucParent.left=successor.right;
15                 //将被删除的右孩子连接到后继节点的右节点上
16                 successor.right=delNode.right;
17                 //将被删除的左孩子连接到后继节点的右节点上（就是用后继节点替换掉被删除的节点）
18             }
19             return successor;
20         }

由于过程比较复杂，这里用图来表示

代码这里左子树直接被嫁接到了被删除节点的后继上面。

这个图很清晰的描述了操作。

这里的找后继的代码默认右子树存在。

删除节点的完成代码：

 1 /**
 2      * 删除节点
 3      * @param key
 4      */
 5     public boolean delete(int key){
 6         Node curr=root;//保存当前节点
 7         Node parent=root;//保存当前节点父节点
 8         boolean isLeft=true;//记录是否是左几点
 9         //定位到将被删除的节点 
10         while(key!=curr.key){
11             if(key<=curr.key){
12                 isLeft=true;//经过左节点
13                 if(curr.left!=null){
14                     parent=curr;
15                     curr=curr.left;
16                 }
17             }else{
18                 isLeft=false;//经过右节点
19                 if(curr.right!=null){
20                     parent=curr;
21                     curr=curr.right;
22                 }
23             }
24             if(curr==null){
25                 return false;
26             }
27         }
28         //如果被删除节点是叶子节点
29         if(curr.left==null&&curr.right==null){
30             if(curr==root){
31                 root=null;
32             }else if(isLeft){
33                 parent.left=null;
34             }else{
35                 parent.right=null;
36             }
37         //如果被删除节点只有左节点
38         }else if(curr.right==null){
39             if(curr==root){
40                 root=root.left;
41             }else if(isLeft){
42                 parent.left=curr.left;
43             }else{
44                 parent.right=curr.left;
45             }
46         //如果被删除节点只有右节点
47         }else if(curr.left==null){
48             if(curr==root){
49                 root=root.right;
50             }else if(isLeft){
51                 parent.left=curr.right;
52             }else{
53                 parent.right=curr.right;
54             }
55         }else{
56             Node successor=getSuccessor(curr);
57             //将后继节点与被删除的父节点进行连接，完成整个替换过程
58             if(curr==root){
59                 root=successor;
60             }else if(curr==parent.left){
61                 parent.left=successor;
62             }else{
63                 parent.right=successor;
64             }
65             successor.left=curr.left;
66         }
67         return true;
68         
69     }
70     
71     public Node getSuccessor(Node delNode){
72         Node curr=delNode.right;
73         Node successor=curr;
74         Node sucParent=null;
75         while(curr!=null){
76             sucParent=successor;
77             successor=curr;
78             curr=curr.left;
79         }
80         if(successor!=delNode.right){
81             //将后继节点的子节点（只可能有右节点）替补到后继节点的位置上
82             sucParent.left=successor.right;
83             //将被删除的右孩子连接到后继节点的右节点上
84             successor.right=delNode.right;
85             //将被删除的左孩子连接到后继节点的右节点上（就是用后继节点替换掉被删除的节点）
86         }
87         return successor;
88     }