[JAVA] AVL

[morskott]

Non so se è permessa una domanda del genere, ma il codice dell'avl che ho scrittoclass AVLElement <T extends Comparable>{
T info;
AVLElement dx;
AVLElement sx;
AVLElement parent;
int prof;
}
public class AVL <T extends Comparable>{
private AVLElement<T> root;
private int numElem;

public AVL(){
this.numElem=0;
}

public boolean add(T elem){
if (root==null){
AVLElement<T> avlelem=new AVLElement<T>();
avlelem.info=elem;
this.root=avlelem;
this.numElem++;
return true;
}else{
boolean ins=insert(elem,this.root,1);
if (!ins) return false;
this.numElem++;
return true;
}
}

private void rotDX(AVLElement<T> elem){
AVLElement<T> parent=elem.parent;
AVLElement<T> b=elem;
AVLElement<T> a=elem.sx;
AVLElement<T> s1=a.sx;
AVLElement<T> s2=a.dx;
AVLElement<T> s3=b.dx;
if (elem.equals(elem.parent.sx)){
parent.sx=a;
}else{
parent.dx=a:
}
a.sx=s1;
s1.parent=a;
a.dx=b;
b.parent=a;
b.sx=s2;
s2.parent=b;
b.dx=s3;
s3.parent=b;
a.parent=parent;
}

private void rotSX(AVLElement<T> elem){
AVLElement<T> parent=elem.parent;
AVLElement<T> a=elem;
AVLElement<T> b=a.dx;
AVLElement<T> s1=a.sx;
AVLElement<T> s2=b.sx;
AVLElement<T> s3=b.dx;
if (elem.equals(elem.parent.sx)){
parent.sx=b;
}else{
parent.dx=b:
}
a.sx=s1;
s1.parent=a;
a.dx=s2;
s2.parent=a;
b.sx=a;
a.parent=b;
b.dx=s3;
s3.parent=b;
b.parent=parent;
}

private void rotSXDX(AVLElement<T> elem){
rotSX(elem.sx);
rotDX(elem);
}

private void rotDXSX(AVLElement<T> elem){
rotDX(elem.dx);
rotSX(elem);
}

private void checkBalance(AVLElement<T> elem){
int balanceIndex= balanceIndex(elem);
if (balanceIndex==2){
int bisx=balanceIndex(elem.sx);
if (bisx==1 || bisx==0){
rotSX(elem);
}
if (bisx==-1){
rotDXSX(elem);
}
}
if (balanceIndex==-2){
int bidx=balanceIndex(elem.dx);
if (bidx==-1 || bidx==0){
rotDX(elem)
}
if (bidx==1){
rotSXDX(elem);
}
}
}

private int balanceIndex(AVLElement<T> elem){
return profondita(elem.sx)-profondita(elem.dx);
}

private int profondita(AVLElement<T> elem){
if (elem==null) return 0;
int profDX=profondita(elem.dx);
int profSX=profondita(elem.sx);
if (profDX>=profSX){
return profDX+1;
}else{
return profSX+1;
}
}

private boolean insert(T elem,AVLElement father,int deep){
if (father.info.equals(elem)) return false;
if (elem.compareTo(father.info)<0){
//inserisci a SX
if (father.sx==null){
AVLElement<T> avlelem=new AVLElement<T>();
avlelem.info=elem;
avlelem.prof=deep;
avelem.parent=father;
father.sx=avlelem;
return true;
}else{
boolean ret= insert(elem,father.sx,deep+1);
if (!ret) return false;
checkBalance(father);
return ret;
}
}else{
//inserisci a DX
if (father.dx==null){
AVLElement<T> avlelem=new AVLElement<T>();
avlelem.info=elem;
avlelem.prof=deep;
avelem.parent=father;
father.dx=avlelem;
return true;
}else{
boolean ret= insert(elem,father.dx,deep+1);
if (!ret) return false;
checkBalance(father);
return ret;
}
}
}


public void remove(T elem){
AVLElement<T> temp=this.root;
this.root=null;
this.numElem=0;
insertAll(temp,elem);
}

public void insertAll(AVLElement<T> elem,T info){
if (elem==null) return;
if (!elem.info.equals(info))this.add(elem.info);
insertAll(elem.sx,info);
insertAll(elem.dx,info);
}

public boolean contains(T elem){
return contains(this.root,elem);
}

public boolean contains(AVLElement<T> elem,T info{
if (elem==null) return false;
if (elem.info.equals(info)) return true;
if (info.compareTo(elem.info)<0) return contains(elem.sx,info);
return contains(elem.dx,info);
}
}è giusto?? Soprattutto l'inserimento, che so che al delete ho scritto la peggio cosa possibile (funziona, ma è di costo non minimo)