爲什麼這個二叉樹碼錯了？

Question

我編碼的東西，我認爲是我的編程類的簡單，但我有點卡住：S，有人可以看看我的代碼，並幫助我嗎？ Thx
Der = right;
Izq = left;

public boolean eliminaDatoABB(T dato){  
     if(this.isEmpty()||this.containsABBRecursivo(dato)==false) 
      return false; 
     return eliminaDatoABBUtil(this.raiz, dato); 

    } 

    private boolean deleteDatumABBUtil(NodeTree<T> nodo, T datum){ 
    if(nodo==null) 
     return false; 
    int i = nodo.nodeValue.compareTo(dato); 
    if(i==0){ //Found it 
     //Cases 
     if(isLeaf(nodo)){ //Is leaf 
      nodo=null; 
      return true; 
     } 
     else 
      if((hasChildRight(nodo)&&!hasChildLeft(nodo))){ //Has just one child at right 
       NodoArbol<T> tmp = new NodoArbol<T>(nodo.der.nodeValue); 
       tmp.der=nodo.der.der; 
       tmp.izq=nodo.der.izq; 
       nodo=tmp; 
       //The trash collector should then delete the nodo.der 
       return true; 
      } 
      else 
       if((!hasChildRight(nodo)&&hasChildLeft(nodo))){ //Has just one child at left 
        NodoArbol<T> tmp = new NodoArbol<T>(nodo.izq.nodeValue); 
        tmp.izq=nodo.izq.izq; 
        tmp.der=nodo.izq.der; 
        nodo=tmp; 
        //The trash collector should then delete the nodo.izq 
        return true; 
       } 
       else{ //Has two children 
        NodoArbol<T> tmp = this.predecesor(nodo); 
        tmp.der=nodo.der; 
        tmp.izq=nodo.izq; 
        return deleteDatumABB(nodo.izq.nodeValue); 
       } 
    } 
    else{ //Search the datum 
     if(i>0) 
      return deleteDatumABBUtil(nodo.izq, dato); 
     else 
      return deleteDatumABBUtil(nodo.der, dato); 
    } 
} 

//Bonus Methods 

public boolean isLeaf(NodeTree<T> nodo){ 
    return (nodo.der==null&&nodo.izq==null); 
} 

public boolean hasChildRight(NodeTree<T> nodo){ 
    return nodo.der!=null; 
} 

public boolean hasChildLeft(NodeTree<T> nodo){ 
    return nodo.izq!=null; 
} 

它沒有任何的3例工作：S

Answer 1

我覺得這段代碼看起來可疑

nodo.der.der=nodo.der; 
nodo.der.izq=nodo.izq; 

你看，在這裏你指定的nodo到nodo兒童然後執行以下操作：

nodo = nodo.der 

其實你有nodo.der == nodo.der，所以我懷疑你是否真的想達到這樣的目的。

只需查看這些代碼段，我相信你會發現你錯了。

Answer 2

在代碼中的一些更可疑的地方：

NodoArbol<T> tmp = this.predecesor(nodo); 
tmp.der=nodo.der; 
tmp.izq=nodo.izq; 
return deleteDatumABB(nodo.izq.nodeValue); 

首先，如果真的this.predecesor(nodo)返回nodo的predecesor那麼你爲什麼要重寫它的孩子嗎？

二，deleteDatumABB(nodo.izq.nodeValue)不應該是deleteDatumABB(tmp, datum)或類似的東西？

而我的評論中的問題是：在只有一個孩子的情況下沒有調用deleteDatumABB？

Answer 3

非常感謝你，Xappymah，我已經成功地糾正我的代碼，現在它就像一個魅力，任何人想瑟代碼，那就是：d：

public boolean deleteDatumABB(T datum){ 
if(this.isEmpty()) 
    return false; 
return deleteDatumABBUtil(this.root, datum); 

} 
private boolean deleteDatumABBUtil(NodeTree<T> nodo, T datum){ 
    if(nodo==null) 
     return false; 
    int i = nodo.nodeValue.compareTo(dato); 
    if(i==0){ //Found it :D 
     //Base cases 
     if(isLeaf(nodo)){ //Is Leaf 
      if(this.root==nodo){ 
       this.root=null; 
       return true; 
      } 
      else{ 
       NodeTree<T> parent = getParentABBRecursivePriv(root, datum); 
       if(dato.compareTo(parent.nodeValue)<0) 
        parent.izq=null; 
       else 
        parent.der=null;  
       return true; 
      } 
     } 
     else 
      if((hasChildRight(nodo)&&!hasChildLeft(nodo))){ //Just one kind at right 
       if(nodo==this.root){ 
        this.root=nodo.der; 
        return true; 
       } 
       else{ 
        NodeTree<T> parent = getParentABBRecursivoPriv(root, dato); 
        if(datum.compareTo(prent.nodeValue)<0) 
         parent.izq = nodo.der; 
        else 
         parent.der = nodo.der; 
        return true; 
       } 
      } 
      else 
       if((!hasChildRight(nodo)&&hasChildLeft(nodo))){ //TJust one child at left 
        if(nodo==this.root){ 
         this.root=nodo.izq; 
         return true; 
        } 
        else{ 
         NodeTree<T> parent = getParentABBRecursivePriv(root, datum); 
         if(datum.compareTo(parent.nodeValue)<0) 
          parent.izq = nodo.izq; 
         else 
          parent.der = nodo.izq; 
         return true; 
        } 
       } 
       else{ //Children in both 
        if(nodo==this.raiz){ 

         NodoArbol<T> pred = new NodeTree<T>(predecesor(nodo).nodeValue); 
         pred.der = this.root.der; 
         pred.izq = this.root.izq; 

         this.root = pred; 
         deleteDatumABBUtil(nodo.izq, root.nodeValue); 



         return true; 
        } 
        else{ 

         NodeTree<T> parent = getParentABBRecursivePriv(root, datum); 
         NodoArbol<T> pred = new NodeTress<T>(predecesor(nodo).nodeValue); 
         pred.der = padre.der.der; 
         pred.izq = padre.der.izq; 
         deleteDatumABBUtil(nodo.izq, pred.nodeValue); 
         parent.der = pred; 
         return true; 
        } 

       } 
    } 
    else{ //Search 
     if(i>0) 
      return deleteDatumABBUtil(nodo.izq, datum); 
     else 
      return deleteDatumABBUtil(nodo.der, datum); 
    } 
}