[JAVA] AVL

[morskott]

Non so se è permessa una domanda del genere, ma il codice dell'avl che ho scritto

class 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)