日常学习随笔-用链表的形式实现普通二叉树的删除（源码+说明）（补充篇）

一、二叉树删除的三种情况

删除二叉树查找树的节点吧。总共有三种情况

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

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

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

或者

二、源码案例：

完整的二叉树类：

二叉树完整自定义源码：

package com.xfwl.algorithmAnalysis.trees;
/**
 * 二叉树结构分析
 * @function  日常学习测试
 * @author 小风微凉
 * @time  2018-5-20 下午12:28:50
 */
public class MyTreeDefin<T extends Comparable<? super T>>{
    /**
     * 每棵树都有一个根节点
     */
    private BinaryNode<T> root;
    /**
     * 整棵树的节点个数
     */
    private int nodeCount;
    /**
     * 二叉树构造器
     */
    public MyTreeDefin(){
        this.reset();
    }
    /**
     * 重置整棵树的结构
     */
    private void reset(){
        //二叉树的根节点初始化
        root=null;
        //二叉树的节点总数：归0
        this.nodeCount=0;
    }
    /**
     * 清空整棵二叉树
     * @return
     */
    public boolean makeEmpty(){
        this.reset();
        return this.isEmpty();
    }
    /**
     * 获取树的节点个数
     * @return
     */
    public int getSize(){
        return this.nodeCount;
    }
    /**
     * 判断整棵树是否为空树
     * @return
     */
    public boolean isEmpty(){
        return this.nodeCount==0?true:false;
    }
    /**
     * 判断二叉树中指定节点后面是否包含指定数据
     * @param target  检索数据target
     * @param node    指定的节点（包含当前节点）
     * @return
     */
    public boolean contains(T target,BinaryNode<T> node){
        //判空检查
        if(node==null){
            return false;
        }
        //先和当前节点的数据比较
        int compareResult=target.compareTo(node.elem);
        if(compareResult>0){//进入右子树中继续判断
            return contains(target,node.right);
        }else if(compareResult<0){//进入左子树中继续判断
            return contains(target,node.left);
        }else{//相等
            return true;
        }
    }
    /**
     * 从根节点开始查找整棵树是否包含指定的数据
     * @param target 检索数据target
     * @return
     */
    public boolean contains(T target){
        return this.contains(target, this.root);
    }
    /**
     * 查找整棵树中的最小数据
     * 左子树最后一个节点数据
     * @return
     */
    public T findMin(){
        return this.findMin(this.root).elem;
    }
    /**
     * 查找指定树节点下面的最小节点[查找指定节点后面的最小节点]
     * @param node    指定的节点
     * @return
     */
    public BinaryNode<T> findMin(BinaryNode<T> node){
        //如果节点为空
        if(node==null){
            return null;
        }else if(node.left==null){//递归基准情况
            return node;
        }else{//递归流程
            return findMin(node.left);
        }
    }
    /**
     * 查找指定树节点下面的最大节点[最大的数据在右子树的最深叶子节点]
     * @param node   指定的查找起点节点
     * @return
     */
    public BinaryNode<T> findMax(BinaryNode<T> node){
        //如果节点为空
        if(node==null){
            return null;
        }else if(node.right==null){//递归基准情况
            return node;
        }else{//递归流程
            return findMax(node.right);
        }
    }
    /**
     * 查找整棵树中的最大数据
     * @return
     */
    public T findMax(){        
        return this.findMax(this.root).elem;
    }
    /**
     * 为二叉树添加新的节点（对外）
     * @param data 要添加的数据
     * @return
     */
    public BinaryNode<T> add(T data){
        if(this.isEmpty()){
            this.nodeCount++;
            this.root=new BinaryNode<>(data,null,null);
            return this.root;
        }else{
            this.nodeCount++;
            return this.add(data, this.root);
        }        
    }
    /**
     * 为二叉树添加新的节点（对内）
     * @param data 要添加的数据
     * @param curNode 要添加的节点（递归比较）
     */
    private BinaryNode<T> add(T data,BinaryNode<T> curNode){
        //如果节点不存在：递归基准情况
        if(curNode==null){
            return new BinaryNode<>(data,null,null);
        }
        //按照：左>根>右  的大小顺序插入二叉树中
        //比较起点：先和根节点数据比较
        int compareResult=data.compareTo(curNode.elem);
        if(compareResult<0){//走左子树
            System.out.println("左<--");
            curNode.left=this.add(data,curNode.left);
        }else if(compareResult>0){//走右子树
            System.out.println("-->右");
            curNode.right=this.add(data,curNode.right);
        }else{//如果添加的节点数据和当前比较的根节点相同
            //不做任何处理，可在此继续扩展
        }                
        //返回的是根节点
        return curNode;
    }
    /**
     * 非递归添加树节点
     * @param data 节点数据
     * @return
     */
    public void  push(T data){
        if(this.isEmpty()){//空树结构
            this.nodeCount++;
            this.root=new BinaryNode<>(data,null,null);
        }else{//至少含有一个根节点
            BinaryNode<T> tmpNode =this.root;
            System.out.println("--------------------根节点数据："+tmpNode.elem+",--------------------");
            while(true){
                System.out.println("while----：tmpNode.elem="+tmpNode.elem+",data="+data);
                int compareResult=data.compareTo(tmpNode.elem);
                if(compareResult<0){//走左子树
                    System.out.println("左<--");
                    if(tmpNode.left==null){
                        tmpNode.left=new BinaryNode<>(data,null,null);
                        break;
                    }
                    tmpNode=tmpNode.left;
                }else if(compareResult>0){//走右子树
                    System.out.println("-->右");
                    if(tmpNode.right==null){
                        tmpNode.right=new BinaryNode<>(data,null,null);
                        break;
                    }
                    tmpNode=tmpNode.right;
                }else{//替换当前节点数据（压入相同数据，没改变）
                    //也即不做处理
                    break;
                }
            }
            this.nodeCount++;
        }
    }
    /**
     * 移除二叉树中根节点后面的指定数据（所在的节点）
     * @param data  指定的数据
     */
    public boolean remove(T data){
        boolean ret=false;
        //要删除的数据所在的结点存在
        if(!this.contains(data)){
            return ret;
        }
        //要删除的节点
        BinaryNode<T> target=this.getNode(data, this.root);
        if(target!=null){
            //要删除的节点的上一级节点
            BinaryNode<T> parNode= this.getPrevNode(data);
            System.out.println("parNode==null:"+(parNode==null));
            //（1）当前节点为叶子节点
            if(target.left==null && target.right==null){
                target=null;
                if(parNode!=null){
                    if(data.compareTo(parNode.elem)>0){//右子树
                        parNode.right=null;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        parNode.left=null;
                    }                    
                }else{//删除的是根节点
                    this.root=null;
                }
                ret=true;
            }
            //（2）只有一个子树（左或者右）
            else if(target.left!=null && target.right==null){
                target=target.left;
                if(parNode!=null){
                    if(data.compareTo(parNode.elem)>0){//右子树
                        parNode.right=target;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        parNode.left=target;
                    }                    
                }else{//删除的是根节点
                    this.root=this.root.left;
                }
                ret=true;
            }else if(target.left==null && target.right!=null){
                target=target.right;
                if(parNode!=null){
                    if(data.compareTo(parNode.elem)>0){//右子树
                        parNode.right=target;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        parNode.left=target;
                    }                    
                }else{//删除的是根节点
                    this.root=this.root.right;
                }
                ret=true;
            }
            //（3）左右子树都有
            /**
             * 最麻烦的一种删除方式：
             * [1]找到要删除节点的父节点，判断当前节点是在父节点的左子树还是右子树。
             * [2]找到当前删除节点的左子树的最大节点，替换当前删除节点。
             * [3]当前删除节点的左子树的最大节点的父节点（针对这个节点的指向清空）
             * [4]重新设置新结点的左右子树的指向
             */
            else if(target.left!=null && target.right!=null){
                //1.取左子树的最大数据节点
                BinaryNode<T> lmaxNode=this.findMax(target.left);
                if(parNode!=null){//删除的非根节点
                    if(data.compareTo(parNode.elem)>0){//右子树
                        //2.左子树最大数据节点的上级节点
                        BinaryNode<T> maxParNode=this.getPrevNode(lmaxNode.getElem());
                        if(lmaxNode.getElem().compareTo(maxParNode.elem)>0){
                            if(lmaxNode.left!=null){
                                maxParNode.right=lmaxNode.left;                            
                            }else{
                                maxParNode.right=null;                            
                            }
                        }else if(lmaxNode.getElem().compareTo(maxParNode.elem)<0){
                            //特别注意：当maxParNode的上一级就是target的时候，需要特殊处理
                            if(maxParNode.elem.equals(target.elem)){
                                maxParNode.left=lmaxNode.left;
                            }else{
                                maxParNode.left=null;
                            }
                        }
                        //3.替换当前删除节点
                        lmaxNode.left=target.left;
                        lmaxNode.right=target.right;                        
                        parNode.right=lmaxNode;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        //2.左子树最大数据节点的上级节点
                        BinaryNode<T> maxParNode=this.getPrevNode(lmaxNode.getElem());
                        if(lmaxNode.getElem().compareTo(maxParNode.elem)>0){
                            if(lmaxNode.left!=null){
                                maxParNode.right=lmaxNode.left;                            
                            }else{
                                maxParNode.right=null;                            
                            }
                        }else if(lmaxNode.getElem().compareTo(maxParNode.elem)<0){
                            //特别注意：当maxParNode的上一级就是target的时候，需要特殊处理
                            if(maxParNode.elem.equals(target.elem)){
                                maxParNode.left=lmaxNode.left;
                            }else{
                                maxParNode.left=null;
                            }
                        }
                        //3.替换当前删除节点
                        lmaxNode.left=target.left;
                        lmaxNode.right=target.right;                        
                        parNode.left=lmaxNode;
                    }                    
                }else{//删除的是根节点
                    //2.左子树最大数据节点的上级节点
                    BinaryNode<T> maxParNode=this.getPrevNode(lmaxNode.getElem());
                    if(lmaxNode.getElem().compareTo(maxParNode.elem)>0){
                        if(lmaxNode.left!=null){
                            maxParNode.right=lmaxNode.left;                            
                        }else{
                            maxParNode.right=null;                            
                        }
                    }else if(lmaxNode.getElem().compareTo(maxParNode.elem)<0){
                        //特别注意：当maxParNode的上一级就是target的时候，需要特殊处理
                        if(maxParNode.elem.equals(target.elem)){
                            maxParNode.left=lmaxNode.left;
                        }else{
                            maxParNode.left=null;
                        }
                    }
                    //3.替换当前删除节点
                    lmaxNode.left=target.left;
                    lmaxNode.right=target.right;
                    this.root=lmaxNode;
                }
                ret=true;
            }
        }            
        this.nodeCount=(ret==true?--this.nodeCount:this.nodeCount);
        //找到要删除的节点        
        return ret;
    }
    public T getPrevNodeElem(T data){
        return this.getPrevNode(data).getElem();
    }
    /**
     * 根据节点数据找到对应的节点的父节点
     * @param data 节点数据
     * @return
     */
    public BinaryNode<T> getPrevNode(T data){
        if(this.isEmpty()){//空树
            return null;
        }
        if(data.equals(root.getElem())){
            return null;
        }
        BinaryNode<T> parNode=this.root;//父节点
        BinaryNode<T> curNode=this.root;//当前节点
        while(true){
            int compareResult=data.compareTo(curNode.elem);
            if(compareResult>0){//进入右子树中继续判断                
                /*parNode.elem=curNode.elem;
                parNode.left=curNode.left;
                parNode.right=curNode.right;*/
                parNode=curNode;
                curNode=curNode.right;                
            }else if(compareResult<0){//进入左子树中继续判断
                /*parNode.elem=curNode.elem;
                parNode.left=curNode.left;
                parNode.right=curNode.right;*/
                parNode=curNode;
                
                curNode=curNode.left;
            }else{//相等
                break;
            }
        }
        return parNode;
    }
    /**
     * 根据节点数据找到对应的节点
     * @param data 节点数据
     * @param node 
     * @return
     */
    public BinaryNode<T> getNode(T data,BinaryNode<T> node){
        //不存在节点
        if(this.isEmpty()){
            return  null;
        }
        //先和当前节点的数据比较
        int compareResult=data.compareTo(node.elem);
        if(compareResult>0){//进入右子树中继续判断
            return getNode(data,node.right);
        }else if(compareResult<0){//进入左子树中继续判断
            return getNode(data,node.left);
        }else{//相等
            return node;
        }
    }
    /**
     * 打印树结构信息
     * @param index  遍历的类型
     * 一般用到的遍历方式有三种：
     * （1）前序遍历    0
     * （2）中序遍历    1
     * （3）后序遍历    2
     */
    public void printTree(int index){
        String type=(index==0?"前序":index==1?"中序":"后序")+"遍历";
        System.out.println("------------【开始遍历打印·"+type+"】------------");
        switch(index){
            case 0:preOrder(this.root);break;
            case 1:inOrder(this.root);break;
            case 2:postOrder(this.root);break;
        } 
        System.out.println("------------【打印结束】------------");        
    }
    /**
     * 前序遍历
     * @param node  遍历的起始节点
     * 采用递归思想
     *  对左子节点进行遍历
     *  对右子节点进行遍历
     *  递归基值是node是否是null
     */
     private void preOrder(BinaryNode<T> node)
     {
        if(node==null){
            return;
        }else{
            System.out.print(node.elem+" ");//输出数据节点信息
            preOrder(node.left);
            preOrder(node.right);
        }
     }
    /**
     * 中序遍历
     * @param node
     */
    private void inOrder(BinaryNode<T> node){
        if(node==null){
            return;
        }else{
            inOrder(node.left);
            System.out.print(node.elem+" ");
            inOrder(node.right);
        }
    }
    /**
     * 后序遍历
     * @param node
     */
    private void postOrder(BinaryNode<T> node){
        if(node==null){
            return;
        }else{
            postOrder(node.left);
            postOrder(node.right);
            System.out.print(node.elem+" ");
        }
    }
    /**
     * 获取指定节点的数据
     * @param node
     * @return
     */
    public T getElem(BinaryNode<T> node){
        if(node==null){
            return null;
        }
        return node.elem;
    }
    /**
     * 内置一个树节点类
     */
    private static class BinaryNode<T>{
        /**
         * 树节点存放数据域
         */
        T elem;
        /**
         * 左子树节点域
         */
        BinaryNode<T> left;
        /**
         * 右子树节点域
         */
        BinaryNode<T> right;
        /**
         * 构造器
         */
        public BinaryNode(T elem,BinaryNode<T> left,BinaryNode<T> right){
            this.elem=elem;
            this.left=left;
            this.right=right;
        }
        public T getElem(){
            return this.elem;
        }
    }
}
  

 删除功能的代码如下：

（1）根据数据找到二叉树中的结点

/**
     * 根据节点数据找到对应的节点
     * @param data 节点数据
     * @param node 
     * @return
     */
    public BinaryNode<T> getNode(T data,BinaryNode<T> node){
        //不存在节点
        if(this.isEmpty()){
            return  null;
        }
        //先和当前节点的数据比较
        int compareResult=data.compareTo(node.elem);
        if(compareResult>0){//进入右子树中继续判断
            return getNode(data,node.right);
        }else if(compareResult<0){//进入左子树中继续判断
            return getNode(data,node.left);
        }else{//相等
            return node;
        }
    }

 （2）查找删除数据的上一级节点

/**
     * 根据节点数据找到对应的节点的父节点
     * @param data 节点数据
     * @return
     */
    public BinaryNode<T> getPrevNode(T data){
        if(this.isEmpty()){//空树
            return null;
        }
        if(data.equals(root.getElem())){
            return null;
        }
        BinaryNode<T> parNode=this.root;//父节点
        BinaryNode<T> curNode=this.root;//当前节点
        while(true){
            int compareResult=data.compareTo(curNode.elem);
            if(compareResult>0){//进入右子树中继续判断                
                /*parNode.elem=curNode.elem;
                parNode.left=curNode.left;
                parNode.right=curNode.right;*/
                parNode=curNode;
                curNode=curNode.right;                
            }else if(compareResult<0){//进入左子树中继续判断
                /*parNode.elem=curNode.elem;
                parNode.left=curNode.left;
                parNode.right=curNode.right;*/
                parNode=curNode;
                
                curNode=curNode.left;
            }else{//相等
                break;
            }
        }
        return parNode;
    }

 （3）判断二叉树是否包含要删除的数据

/**
     * 判断二叉树中指定节点后面是否包含指定数据
     * @param target  检索数据target
     * @param node    指定的节点（包含当前节点）
     * @return
     */
    public boolean contains(T target,BinaryNode<T> node){
        //判空检查
        if(node==null){
            return false;
        }
        //先和当前节点的数据比较
        int compareResult=target.compareTo(node.elem);
        if(compareResult>0){//进入右子树中继续判断
            return contains(target,node.right);
        }else if(compareResult<0){//进入左子树中继续判断
            return contains(target,node.left);
        }else{//相等
            return true;
        }
    }

 （4）查找二叉树指定结点的左子树中最大的节点

/**
     * 查找指定树节点下面的最大节点[最大的数据在右子树的最深叶子节点]
     * @param node   指定的查找起点节点
     * @return
     */
    public BinaryNode<T> findMax(BinaryNode<T> node){
        //如果节点为空
        if(node==null){
            return null;
        }else if(node.right==null){//递归基准情况
            return node;
        }else{//递归流程
            return findMax(node.right);
        }
    }
    /**
     * 查找整棵树中的最大数据
     * @return
     */
    public T findMax(){        
        return this.findMax(this.root).elem;
    }

 （5）*删除指定数据所在的节点

/**
     * 移除二叉树中根节点后面的指定数据（所在的节点）
     * @param data  指定的数据
     */
    public boolean remove(T data){
        boolean ret=false;
        //要删除的数据所在的结点存在
        if(!this.contains(data)){
            return ret;
        }
        //要删除的节点
        BinaryNode<T> target=this.getNode(data, this.root);
        if(target!=null){
            //要删除的节点的上一级节点
            BinaryNode<T> parNode= this.getPrevNode(data);
            System.out.println("parNode==null:"+(parNode==null));
            //（1）当前节点为叶子节点
            if(target.left==null && target.right==null){
                target=null;
                if(parNode!=null){
                    if(data.compareTo(parNode.elem)>0){//右子树
                        parNode.right=null;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        parNode.left=null;
                    }                    
                }else{//删除的是根节点
                    this.root=null;
                }
                ret=true;
            }
            //（2）只有一个子树（左或者右）
            else if(target.left!=null && target.right==null){
                target=target.left;
                if(parNode!=null){
                    if(data.compareTo(parNode.elem)>0){//右子树
                        parNode.right=target;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        parNode.left=target;
                    }                    
                }else{//删除的是根节点
                    this.root=this.root.left;
                }
                ret=true;
            }else if(target.left==null && target.right!=null){
                target=target.right;
                if(parNode!=null){
                    if(data.compareTo(parNode.elem)>0){//右子树
                        parNode.right=target;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        parNode.left=target;
                    }                    
                }else{//删除的是根节点
                    this.root=this.root.right;
                }
                ret=true;
            }
            //（3）左右子树都有
            /**
             * 最麻烦的一种删除方式：
             * [1]找到要删除节点的父节点，判断当前节点是在父节点的左子树还是右子树。
             * [2]找到当前删除节点的左子树的最大节点，替换当前删除节点。
             * [3]当前删除节点的左子树的最大节点的父节点（针对这个节点的指向清空）
             * [4]重新设置新结点的左右子树的指向
             */
            else if(target.left!=null && target.right!=null){
                //1.取左子树的最大数据节点
                BinaryNode<T> lmaxNode=this.findMax(target.left);
                if(parNode!=null){//删除的非根节点
                    if(data.compareTo(parNode.elem)>0){//右子树
                        //2.左子树最大数据节点的上级节点
                        BinaryNode<T> maxParNode=this.getPrevNode(lmaxNode.getElem());
                        if(lmaxNode.getElem().compareTo(maxParNode.elem)>0){
                            if(lmaxNode.left!=null){
                                maxParNode.right=lmaxNode.left;                            
                            }else{
                                maxParNode.right=null;                            
                            }
                        }else if(lmaxNode.getElem().compareTo(maxParNode.elem)<0){
                            //特别注意：当maxParNode的上一级就是target的时候，需要特殊处理
                            if(maxParNode.elem.equals(target.elem)){
                                maxParNode.left=lmaxNode.left;
                            }else{
                                maxParNode.left=null;
                            }
                        }
                        //3.替换当前删除节点
                        lmaxNode.left=target.left;
                        lmaxNode.right=target.right;                        
                        parNode.right=lmaxNode;
                    }else if(data.compareTo(parNode.elem)<0){//左子树
                        //2.左子树最大数据节点的上级节点
                        BinaryNode<T> maxParNode=this.getPrevNode(lmaxNode.getElem());
                        if(lmaxNode.getElem().compareTo(maxParNode.elem)>0){
                            if(lmaxNode.left!=null){
                                maxParNode.right=lmaxNode.left;                            
                            }else{
                                maxParNode.right=null;                            
                            }
                        }else if(lmaxNode.getElem().compareTo(maxParNode.elem)<0){
                            //特别注意：当maxParNode的上一级就是target的时候，需要特殊处理
                            if(maxParNode.elem.equals(target.elem)){
                                maxParNode.left=lmaxNode.left;
                            }else{
                                maxParNode.left=null;
                            }
                        }
                        //3.替换当前删除节点
                        lmaxNode.left=target.left;
                        lmaxNode.right=target.right;                        
                        parNode.left=lmaxNode;
                    }                    
                }else{//删除的是根节点
                    //2.左子树最大数据节点的上级节点
                    BinaryNode<T> maxParNode=this.getPrevNode(lmaxNode.getElem());
                    if(lmaxNode.getElem().compareTo(maxParNode.elem)>0){
                        if(lmaxNode.left!=null){
                            maxParNode.right=lmaxNode.left;                            
                        }else{
                            maxParNode.right=null;                            
                        }
                    }else if(lmaxNode.getElem().compareTo(maxParNode.elem)<0){
                        //特别注意：当maxParNode的上一级就是target的时候，需要特殊处理
                        if(maxParNode.elem.equals(target.elem)){
                            maxParNode.left=lmaxNode.left;
                        }else{
                            maxParNode.left=null;
                        }
                    }
                    //3.替换当前删除节点
                    lmaxNode.left=target.left;
                    lmaxNode.right=target.right;
                    this.root=lmaxNode;
                }
                ret=true;
            }
        }            
        this.nodeCount=(ret==true?--this.nodeCount:this.nodeCount);
        //找到要删除的节点        
        return ret;
    }

测试类：

package com.xfwl.algorithmAnalysis.trees;

public class Test {
    /**
     * @param args
     */
    public static void main(String[] args) {
        //创建一棵树
        MyTreeDefin<Integer> tree=new MyTreeDefin<>();
        //压入数据
        tree.push(5);
        tree.push(2);
        tree.push(4);
        tree.push(8);
        tree.push(7);
        tree.push(11);
        tree.push(3);
        tree.push(9);
        tree.push(6);
        tree.push(1);
        tree.push(0);
        tree.push(10);
        System.out.println(tree.getSize());
        //开始遍历显示
        //tree.printTree(0);
        //tree.printTree(1);
        //tree.printTree(2);
        //删除
        tree.remove(5); 
        tree.printTree(1);
        //System.out.println(tree.getSize());
        
        //System.out.println(tree.getPrevNodeElem(2));
    }
}

 运行结果比较多，就不一一展示在这里了！