Java 删除方法二叉搜索树

我正在尝试为我一直在研究的BST结构实现一个remove方法。以下是具有查找、插入和删除方法的代码：

public class BST {
    BSTNode root = new BSTNode("root");

    public void insert(BSTNode root, String title){
        if(root.title!=null){

            if(title==root.title){
                //return already in the catalog
            }
            else if(title.compareTo(root.title)<0){

                if(root.leftChild==null){
                    root.leftChild = new BSTNode(title);
                }
                else{
                    insert(root.leftChild,title);
                }
            }
            else if(title.compareTo(root.title)>0){
                if(root.rightChild==null){
                    root.rightChild = new BSTNode(title);
                }
                else{
                    insert(root.rightChild,title);
                }
            }
        }
    }

    public void find(BSTNode root, String title){
        if(root!= null){
            if(title==root.title){
                //return(true);
            }
            else if(title.compareTo(root.title)<0){
                find(root.leftChild, title);
            }
            else{
                find(root.rightChild, title);
            }
        }
        else{
            //return false;
        }
    }

    public void remove(BSTNode root, String title){
        if(root==null){
            return false;
        }
        if(title==root.title){
            if(root.leftChild==null){
                root = root.rightChild;
            }
            else if(root.rightChild==null){
                root = root.leftChild;
            }
            else{
                //code if 2 chlidren remove
            }
        }
        else if(title.compareTo(root.title)<0){
            remove(root.leftChild, title);
        }
        else{
            remove(root.rightChild, title);
        }
    }
}

公共类BST{
BSTNode root=新的BSTNode（“根”）；
公共void插入（节点根，字符串标题）{
if（root.title！=null）{
if（title==root.title）{
//已在目录中返回
}
else if（title.compareTo（root.title）0）{
if（root.rightChild==null）{
root.rightChild=新节点（标题）；
}
否则{
插入（root.righchild，title）；
}
}
}
}
公共void查找（节点根，字符串标题）{
if（root！=null）{
if（title==root.title）{
//返回（真）；
}
else if（title.compareTo（root.title）要在java中比较对象，请使用.equals（）方法而不是“==”运算符

你需要像这样使用

 if(title.equals(root.title)) 

或者，如果您有兴趣忽略该案例，请遵循以下代码

 if(title.equalsIgnoreCase(root.title))

public void remove（字符串键，BSTNode位置）
{
如果（pos==null）返回；
如果（键比较到（位置键）0）
移除（钥匙，位置右侧儿童）；
否则{
if（pos.leftChild！=null&&pos.righchild！=null）
{
/*他有两个孩子*/
BSTNode maxFromLeft=findMax（pos.leftChild）；//需要创建findMax帮助程序
//将“pos.key”替换为“maxFromLeft.key”
pos.key=maxFromLeft.key；
移除（maxFromLeft.key，位置leftChild）；
}
else if（pos.leftChild！=null）{
/*pos指向的节点最多有一个子节点*/
BST节点垃圾=pos；
//将“pos.leftChild.key”升级为“pos.key”
pos=pos.leftChild；
垃圾=null；
}
else if（pos.rightChild！=null）{
/*pos指向的节点最多有一个子节点*/
BST节点垃圾=pos；
/*将“pos.rightChild.key”升级为“pos.key”*/
pos=pos.rightChild；
垃圾=null；
}
否则{
pos=null；
}
}
}

这是一个不平衡树的移除。我有C++代码，所以我已经快速翻译了。可能会有一些小错误。你的编码树是否必须平衡？如果需要的话，我也有平衡删除。我不太确定你的问题的措辞。也请你为查找添加一个私人助手函数。最大值（）
<> P>我知道这是一个很古老的问题，但是不管怎样……接受的答案是从C++中实现的，所以指针的概念仍然存在，因为java中没有指针。课程简介摘自一门关于算法的课程

public TreeNode deleteBSTNode(int value,TreeNode node)
{
    if(node==null)
    {
        System.out.println("the value " + value + " is not found");
        return null;
    }
    //delete
    if(node.data>value) node.left = deleteBSTNode(value,node.left);
    else if(node.data<value) node.right = deleteBSTNode(value,node.right);
    else{
        if(node.isLeaf())
            return null;
        if(node.right==null)
            return node.left;
        if(node.left==null)
            return node.right;

        TreeNode successor = findMax(node.left);
        int data = successor.data;
        deleteBSTNode(data, node.left);
        node.data = data;


    }
    return node;
}

public树节点deleteBSTNode（int值，树节点）
{
if（node==null）
{
System.out.println（“未找到值“+value+”）；
返回null；
}
//删除
如果（node.data>value）node.left=deleteBSTNode（value，node.left）；
else if（node.data
void deleteTreeNode（int数据）{
根=删除树节点（根，数据）；
}
私有树节点deleteTreeNode（树节点根，int数据）{
TreeNode cur=根；
如果（cur==null）{
返回电流；
}
如果（当前数据>数据）{
cur.left=删除树节点（cur.left，数据）；
}否则如果（当前数据<数据）{
cur.right=删除树节点（cur.right，数据）；
}否则{
if（cur.left==null&&cur.right==null）{
cur=null；
}else if（cur.right==null）{
cur=cur.left；
}else if（cur.left==null）{
cur=cur.right；
}否则{
树节点温度=findMinFromRight（当前右侧）；
电流数据=温度数据；
cur.right=删除树节点（cur.right，温度数据）；
}
}
返回电流；
}
私有TreeNode findMinFromRight（TreeNode节点）{
while（node.left！=null）{
node=node.left；
}
返回节点；
}
对于深度优先后序的遍历和删除，请使用：

/*
 * 
 *  Remove uses
 *  depth-first Post-order traversal.
 *  
 * The Depth First Post-order traversal follows:
 * Left_Child -> Right-Child -> Node convention
 * 
 * Partial Logic was implemented from this source:
 * https://stackoverflow.com/questions/19870680/remove-method-binary-search-tree
 * by: sanjay
 */
@SuppressWarnings("unchecked")
public BinarySearchTreeVertex<E> remove(BinarySearchTreeVertex<E> rootParameter, E eParameter)  {
    BinarySearchTreeVertex<E> deleteNode = rootParameter;
    
    if ( deleteNode == null )   {
        return deleteNode;  }
    
    if ( deleteNode.compareTo(eParameter) == 1 )    {
        deleteNode.left_child = remove(deleteNode.left_child, eParameter);  }
    
    else if ( deleteNode.compareTo(eParameter) == -1 )  {
        deleteNode.right_child = remove(deleteNode.right_child, eParameter);    }
    
    else    {
        if ( deleteNode.left_child == null && deleteNode.right_child == null )  {
            deleteNode = null;
            }
        
        else if ( deleteNode.right_child == null )  {
            deleteNode = deleteNode.left_child; }
        
        else if ( deleteNode.left_child == null )   {
            deleteNode = deleteNode.right_child;    }
        
        else    {
            BinarySearchTreeVertex<E> interNode = findMaxLeftBranch( deleteNode.left_child );
            deleteNode.e = interNode.e;
            deleteNode.left_child = remove(deleteNode.left_child, interNode.e);
            }
    }   return deleteNode;  }   // End of remove(E e)

/*
 * Checking right branch for the swap value
 */
@SuppressWarnings("rawtypes")
public BinarySearchTreeVertex findMaxLeftBranch( BinarySearchTreeVertex vertexParameter )   {
    while (vertexParameter.right_child != null )    {
        vertexParameter = vertexParameter.right_child;  }
    return vertexParameter; }   // End of findMinRightBranch

/*
* 
*删除使用
*深度优先后序遍历。
*  
*深度优先后序遍历如下所示：
*左子节点->右子节点->节点约定
* 
*部分逻辑是从以下来源实现的：
* https://stackoverflow.com/questions/19870680/remove-method-binary-search-tree
*作者：桑杰
*/
@抑制警告（“未选中”）
公共BinarySearchTreeVertex删除（BinarySearchTreeVertex rootParameter，E eParameter）{
BinarySearchTreeVertex deleteNode=rootParameter；
if（deleteNode==null）{
返回deleteNode；}
if（deleteNode.compareTo（eParameter）==1）{
deleteNode.left_child=remove（deleteNode.left_child，eParameter）；}
else if（deleteNode.compareTo（eParameter）=-1）{
deleteNode.right_child=remove（deleteNode.right_child，eParameter）；}
否则{
if（deleteNode.left_child==null&&deleteNode.right_child==null）{
deleteNode=null；
}
else if（deleteNode.right_child==null）{
deleteNode=deleteNode.left_child；}
else if（deleteNode.left_child==null）{
deleteNode=deleteNode.right\u child；}
否则{
BinarySearchTreeVertex interNode=findMaxLeftBranch（deleteNode.left_子节点）；
deleteNode.e=节间.e；
deleteNode.left_child=remove（deleteNode.left_child，interNode.e）；
}
}返回deleteNode；}//remo结束
public void remove (String key, BSTNode pos)
    {
        if (pos == null) return;
        if (key.compareTo(pos.key)<0)
            remove (key, pos.leftChild);
        else if (key.compareTo(pos.key)>0)
            remove (key, pos.rightChild);
        else {
            if (pos.leftChild != null && pos.rightChild != null)
            {
                /* pos has two children */
                BSTNode maxFromLeft = findMax (pos.leftChild); //need to make a findMax helper 
                //"Replacing "  pos.key " with " maxFromLeft.key
                pos.key = maxFromLeft.key;
                remove (maxFromLeft.key, pos.leftChild);
            }
            else if(pos.leftChild != null) {
                /* node pointed by pos has at most one child */
                BSTNode trash = pos;
                //"Promoting " pos.leftChild.key " to replace " pos.key
                pos = pos.leftChild;
                trash = null;
            }
            else if(pos.rightChild != null) {
                /* node pointed by pos has at most one child */
                BSTNode trash = pos;
                /* "Promoting " pos.rightChild.key" to replace " pos.key */
                pos = pos.rightChild;
                trash = null;
            }
            else {
                pos = null;
            }
        }
    }

private void deleteNode(Node temp, int n) {
    if (temp == null)
        return;
    if (temp.number == n) {
        if (temp.left == null || temp.right == null) {
            Node current = temp.left == null ? temp.right : temp.left;
            if (getParent(temp.number, root).left == temp)
                getParent(temp.number, root).left = current;
            else
                getParent(temp.number, root).right = current;
        } else {
            Node successor = findMax(temp.left);
            int data = successor.number;
            deleteNode(temp.left, data);
            temp.number = data;
        }
    } else if (temp.number > n) {
        deleteNode(temp.left, n);
    } else {
        deleteNode(temp.right, n);
    }
}

public TreeNode deleteBSTNode(int value,TreeNode node)
{
    if(node==null)
    {
        System.out.println("the value " + value + " is not found");
        return null;
    }
    //delete
    if(node.data>value) node.left = deleteBSTNode(value,node.left);
    else if(node.data<value) node.right = deleteBSTNode(value,node.right);
    else{
        if(node.isLeaf())
            return null;
        if(node.right==null)
            return node.left;
        if(node.left==null)
            return node.right;

        TreeNode successor = findMax(node.left);
        int data = successor.data;
        deleteBSTNode(data, node.left);
        node.data = data;


    }
    return node;
}

void deleteTreeNode(int data){
    root = deleteTreeNode(root ,data);
}

private TreeNode deleteTreeNode(TreeNode root, int data) {
    TreeNode cur = root;
    if(cur == null){
        return cur;
    }
    if(cur.data > data){            
        cur.left = deleteTreeNode(cur.left, data);
    }else if(cur.data < data){
        cur.right = deleteTreeNode(cur.right, data);
    }else{          
        if(cur.left == null && cur.right == null){
            cur = null;
        }else if(cur.right == null){
            cur = cur.left;
        }else if(cur.left == null){
            cur = cur.right;
        }else{
            TreeNode temp  = findMinFromRight(cur.right);
            cur.data = temp.data;
            cur.right = deleteTreeNode(cur.right, temp.data);
        }
    }
    return cur;
}

private TreeNode findMinFromRight(TreeNode node) {
    while(node.left != null){
        node = node.left;
    }
    return node;
}

/*
 * 
 *  Remove uses
 *  depth-first Post-order traversal.
 *  
 * The Depth First Post-order traversal follows:
 * Left_Child -> Right-Child -> Node convention
 * 
 * Partial Logic was implemented from this source:
 * https://stackoverflow.com/questions/19870680/remove-method-binary-search-tree
 * by: sanjay
 */
@SuppressWarnings("unchecked")
public BinarySearchTreeVertex<E> remove(BinarySearchTreeVertex<E> rootParameter, E eParameter)  {
    BinarySearchTreeVertex<E> deleteNode = rootParameter;
    
    if ( deleteNode == null )   {
        return deleteNode;  }
    
    if ( deleteNode.compareTo(eParameter) == 1 )    {
        deleteNode.left_child = remove(deleteNode.left_child, eParameter);  }
    
    else if ( deleteNode.compareTo(eParameter) == -1 )  {
        deleteNode.right_child = remove(deleteNode.right_child, eParameter);    }
    
    else    {
        if ( deleteNode.left_child == null && deleteNode.right_child == null )  {
            deleteNode = null;
            }
        
        else if ( deleteNode.right_child == null )  {
            deleteNode = deleteNode.left_child; }
        
        else if ( deleteNode.left_child == null )   {
            deleteNode = deleteNode.right_child;    }
        
        else    {
            BinarySearchTreeVertex<E> interNode = findMaxLeftBranch( deleteNode.left_child );
            deleteNode.e = interNode.e;
            deleteNode.left_child = remove(deleteNode.left_child, interNode.e);
            }
    }   return deleteNode;  }   // End of remove(E e)

/*
 * Checking right branch for the swap value
 */
@SuppressWarnings("rawtypes")
public BinarySearchTreeVertex findMaxLeftBranch( BinarySearchTreeVertex vertexParameter )   {
    while (vertexParameter.right_child != null )    {
        vertexParameter = vertexParameter.right_child;  }
    return vertexParameter; }   // End of findMinRightBranch