二叉树操作（删除）

package d13删除二叉树节点;
//二叉树节点
public class Node {
    //数据项
    public  long date;
    //数据项
    public String sData;
    //左字节点
    public Node leftChild;
    //右子节点
    public Node rightChild;
    //构造方法
    public Node(long value,String sData){
        this.date=value;
        this.sData=sData;
    }
}

package d13删除二叉树节点;


public class Tree {
    //根节点
    public Node root;
    //插入节点
    public void insert(long value,String aValue){
        //封装节点
        Node newNode =new Node(value,aValue);
        //引用当前节点
        Node current = root;
        //引用父节点
        Node parent;
        //如果root为null,也就是第一次插入的时候
        if(root==null){
            root=newNode;
            return;
        }else{
            while(true){
            //父节点指向当前节点
            parent = current;
            //如果当前指向的节点数据比插入的要大，则向左走
            if(current.date>value){
                current = current.leftChild;
                if(current==null){
                    parent.leftChild=newNode;
                    return;
                }
            }else{
                current = current.rightChild;
                if(current==null){
                    parent.rightChild=newNode;
                    return;
                }
            }
            }
        }
    }
    //查找结点
    public Node find(long value){
        //引用当前节点，从根节点开始
        Node current = root;
        //循环，只要查找不等于当前的节点的数据项
        while(current.date>value){
            //进行比较，比较查找值和当前节点的大小
            if(current.date>value){
                current = current.leftChild;
            }else{
                current=current.rightChild;
            }//如果查不到，返回为空
            if(current==null){
                return null;
            }
        }
        return current;

    }
    //删除结点
    public boolean delete(long value){
        //引用当前节点，从根节点开始
        Node current = root;
        //y引用当前节点的父节点
        Node parent = root;
        //是否为左结点
        boolean isLeftChild = true;

        while(current.date!=value){
            parent = current;
            //进行比较，比较查找值和当前节点的大小
            if(current.date>value){
                current = current.leftChild;
                isLeftChild=true;
            }else{
                current=current.rightChild;
                isLeftChild=false;
            }//如果查不到，返回为空
            if(current==null){
                return false;
            }
        }
        //删除叶子节点，也就是该节点没有子节点
        if(current.leftChild==null&&current.rightChild==null){
            if(current==root){
                root=null;
            }
            //如果它是父节点的左子节点
            else if(isLeftChild){
                parent.leftChild=null;
            }else{ 
                parent.rightChild=null;
            }
        }///有一个子节点
        else if(current.rightChild==null){
            if(current==root){
                root=current.leftChild;
            }
            else if(isLeftChild){
                parent.leftChild=current.leftChild;//后面哪个不等于NULL就等于哪个
            }else{
                parent.rightChild=current.leftChild;
            }
        }else if(current.leftChild==null){
            if(current==root){
                root=current.rightChild;
            }
            else if(isLeftChild){
                parent.leftChild=current.rightChild;
            }else{
                parent.rightChild=current.rightChild;
            }
        }//有2个子节点
        else{
            Node successor = getSuccessor(current);
            if(current==root){
                root=successor;
            }else if (isLeftChild){
                parent.leftChild=successor;
            }else{
                parent.rightChild=successor;
            }
            successor.leftChild=current.leftChild;
        }
        return true;
    }
    public Node getSuccessor(Node delNode){
        Node successor = delNode;                   //
        Node successorParent = delNode;  //保留父节点引用
        Node current = delNode.rightChild; 

        while(current!=null){
            successorParent = successor;
            successor = current;
            current = current.leftChild;
        }
        if(successor!=delNode.rightChild){
            successorParent.leftChild=successor.rightChild;
            successor.rightChild=delNode.rightChild;
        }
        return successor;
    }
    //前序遍历
    public void frontOrder (Node localNode){
        if(localNode!=null){
            //访问根节点
            System.out.println(localNode.date+","+localNode.sData);
            //前序遍历左子树
            frontOrder(localNode.leftChild);
            //前序遍历右子树
            frontOrder(localNode.rightChild);
        }
    }
    //中序遍历
    public void inOrder(Node localNode){
        if(localNode!=null){
            //中序遍历左子树
            inOrder(localNode.leftChild);
            //中序遍历根节点
            System.out.println(localNode.date+","+localNode.sData);
            //中序遍历右子树
            inOrder(localNode.rightChild);
        }
    }public void lastOrder(Node localNode){
        if(localNode!=null){
            //中序遍历左子树
            inOrder(localNode.leftChild);
            //中序遍历右子树
            inOrder(localNode.rightChild);
            //中序遍历根节点
            System.out.println(localNode.date+","+localNode.sData);
        }
    }
}