排序二叉树删除指定节点（Java）

排序二叉树删除指定节点

（一）基本思路 {分3种情况}

1. 情况一：若删除节点为叶子节点，那理论上直接删除就行。但操作上，会找到删除节点的父节点 parent，后判断删除节点是其左子节点还是右子节点，后指针置空即可。

2. 情况二：若删除节点有一棵子树(即只有1个子节点)。那就找到该节点的父节点 parent，判断删除节点是其左子节点还是右子节点。后将 parent 对应指针指向删除节点的子节点。那删除节点就被回收删除。

   注1：由于删除节点的子节点可能是左，也可能是右，因此代码上会有2种情况
   	1) 若为parent的左子节点，parent.left = targetNode.left 或 parent.left = targetNode.right
   	2) 若为parent的右字节点，parent.right = targetNode.left 或 parent.right = targetNode.right
   

3. 情况三：若删除节点有两棵子树(即有2个子节点)。那只需从删除节点的右子树中，找到最小节点（那肯定是最底层最左边那个）并临时保存该节点，后将该节点从右子树中删除。最后将临时保存的最小节点完全替换删除节点，即删除节点的 parent 指向最小节点，最小节点的左子节点指向删除节点的左子节点，最小节点的右子节点指向删除节点的右子节点。

   注：实际上，只需取出右子树中最小节点的值，并将其替换删除节点的值，那就实现上述操作。无需太复杂。
   

4. 说明：删除节点有几个子节点，就是有几棵子树。即使子节点为叶子节点，也能看成是只有1个节点的子树。

---

（二）具体操作

5. 设置一个查询方法，专门用来查找并返回删除节点 targetNode

6. 设置一个查询方法，专门用来查找并返回删除节点的父节点 parent

   注：逻辑不难，就上来是基于当前节点判断其左右子节点，若满足，则返回该父节点。若不满足，且子节点不为空，则进入子节点继续判断。整体操作同查询指定节点。
   

7. 处理情况一：只要能找到删除节点和其父节点，那就判断删除节点是否为叶子节点，若是，则将其父节点对应的指针置为 null。

   注：特殊情况，若找到删除节点但找不到其父节点，那说明删除节点为root节点，直接置空即可。
   

8. 处理情况2：若找到，且判断删除节点为只有1棵子树的节点，那就将其父节点对应指针指向其子节点

   注：判断删除节点是"父节点的左/右 + 判断子节点是左/右"，一共就4种情况
   

9. 处理情况3
   1) 设置1个专门方法，用来获取删除节点右子树中最小节点的值。只需不断往左进入，直到最底层最左边，即为最小节点。记录其值，后调用我们当前的删除方法删除该节点即可。
   2) 只需将获取的最小节点值，替换删除节点值即可。

   注：最小节点为叶子节点，调用当前删除方法本身，即是处理情况1，不会死循环。
   

（三）要点

1. 区别查询方法："排序二叉树"因为节点间有大小关系，因此查询指定节点时，无需再像普通二叉树那样遍历全部。即遍历时能进入左节点，就绝对进不去右节点，因此只需用 if…else

2. 理清查询思路，查询返回指定节点，由于在遍历查询的过程，路径是唯一的(基于上述)。当找到满足的节点时，可直接返回。

3. 判断父节点 parent 的哪个指针对应删除节点时，必须先保证指针不为空。因为存在父节点只有1个子节点的情况。

4. 在处理3种情况之前，先判断特殊情况

   1) 找不到指定节点，即 parent 和 targetNode 均为空
   2) 整棵树只有1个root节点，此时 root.left 和 root.right 为空，直接将root置空
   

5. 必须考虑整棵数不只1个节点，但删除的就是root节点的情况。对于情况一，实际为单 root 节点，已经处理。对于情况三，由于是拿右子树最小值替换，所以也可正常处理。但是，对于情况二，由于 root 无父节点，因此拿 parent.left/right，肯定会报空指针异常，必须额外处理。【关键】

   注：使用 if..else，若删除root，则直接将root指向删除节点的子节点即可
   

（四）代码实现

/*排序二叉树的删除*/
public class BinarySortTreeTest{
    
    @Test
    public void test(){
        //...
    }
}


class BinarySortTree{
    private Node root;
    
    // 寻找删除节点(通过节点值)
    public Node searchTargetNode(int val){
        if(root != null){
            return root.search(val);
        }else{
            return null;
        }
    }
    // 寻找删除节点的父节点
    public Node searchParent(int val){
        if(root != null){
            if(root.val == val) return null;  // root没有父节点
            else return root.searchParent(val);
        }else{
            return null;
        }
    }
    
    // 寻找删除节点右子树的最小节点
    public int searchMin(Node R){
        
        // 循环走到最小节点(只要左子节点存在，就移入)
        Node target = R;
        while(target.left != null){ // 无需递归
            target = target.left;
        }
        // 已到达最小节点
        int temp = target.val;
        delNode(temp);
        return temp;
    }
    
    // 删除节点
    public void delNode(int val){
        if(root == null){
            System.out.println("删除失败，当前二叉树为空~");
            return;
        }
        // 1.找删除节点，及其父节点
        Node target = this.searchTargetNode(val);
        Node parent = this.searchParent(val);
        // 2.判断特殊情况
        if(target == null){
            System.out.println("删除失败，找不到指定节点~");
            return;
        } 
        if(root.left == null && root.right == null){ // 整棵树只有root节点
            if(target == root){
                root = null;
            }else{
                System.out.println("删除失败，找不到指定节点~");
            }
            return;
        }
        // 3.判断3种基本情况
        if(target.left == null && target.right == null){ // 3.1 删除节点为叶子节点
            //若为父节点的左子节点 <= 【不清楚是父节点哪个节点，说明父节点有可能是单子节点情况】
            if(parent.left != null && parent.left.val == val){ 
                parent.left == null;
            }else{ // 若为父节点的右子节点
                parent.right = null;
            }
        }else if(target.left != null && target.right != null){ // 3.3 有两棵子树
            int minVal = searchMin(target.right);
            target.val = minVal;  // 替换
        }else{ // 3.2 只有1棵子树
            // 【额外处理删除root节点的情况】
            if(parent != null){
            	if(target.left != null){ // 删除节点存在左子树
                    // 是否为父节点的左子节点，不是则为右子节点【必须考虑父节点为单子节点情况】
                    if(parent.left != null && parent.left.val == val){
                        parent.left = target.left;
                    }else{
                        parent.right = target.left;
                    }
                }else{ // 删除节点存在右子树
                    if(parent.left != null && parent.left.val == val){
                        parent.left = target.right;
                    }else{
                        parent.right = target.right;
                    }
                }   
            }else{ //【解决bug】
                if(target.left != null){
                    root = target.left;
                }else{
                    root = target.right;
                }
            }
        }
    }
}

/*节点类*/
class Node{
    public int val;
    public Node left;
    public Node right;
    
    Node(int val){
        this.val = val;
    }
    
    // 查询删除节点
    public Node search(int val){
        if(this.val == val){
            return this;
        }
        if(this.left != null && val < this.val){
            return this.left.search(val);
        }else if(this.right != null && val >= this.val){
            return this.right.search(val);
        }else{
            return null;
        }
    }
    // 查询删除节点的父节点
    public Node searchParent(int val){
        // 【*】1.同样上来先判断左、右子节点是否满足
        if((this.left != null && this.left.val == val) || 
           (this.right != null && this.right.val == val)){
            return this;
        }else{ // 若左右子节点不满足，则判断能否进入，可以就递归判断
            if(this.left != null && val < this.val){
                return this.left.searchParent(val);
            }else if(this.right != null && val >= this.val){
                return this.right.searchParent(val);
            }else{
                return null;
            }
        }
    }

    // 添加(基于递归)
    public void add(Node newNode){
        if(newNode == null){
            return;
        }
        if(newNode.val < this.val){
            if(this.left == null){  
                this.left = newNode;
            }else{ 
                this.left.add(newNode);
            }
        }else{
            if(this.right == null){
                this.right = newNode;
            }else{
                this.right.add(newNode);
            }
        }
    }
}