// rotacion simple CON izquierdo
        public AVL rotacionSimpleIzquierda()
        {
            // referencia a nueva raiz luego de la rotacion
            AVL nuevaRaiz = this.getHijoIzquierdo();

            // cambio hijo izquierdo de raiz actual
            this.agregarHijoIzquierdo(nuevaRaiz.getHijoDerecho());

            // cambiar hijo derecho de nueva raiz
            nuevaRaiz.agregarHijoDerecho(this);

            // actualizar altura de antigua raiz (this)
            this.actualizarAltura();

            // actualizar altua de nueva raiz
            nuevaRaiz.actualizarAltura();

            // retornamos nueva raiz
            return(nuevaRaiz);
        }
        public AVL agregar(IComparable elem)
        {
            // si elem es mayor que el dato almacenado en la raiz

            if (((AVL)elem).CompareTo(this) > 0)
            {
                // si el hijo derecho esta vacio, insero elem en ese lugar
                if (this.getHijoDerecho() == null)
                {
                    this.agregarHijoDerecho((AVL)elem);
                }
                else
                {
                    // si el arbol derecho NO esta vacio, llamo recursivamente a agregar()
                    AVL nuevoHijoDerecho = this.getHijoDerecho().agregar(elem);
                    this.agregarHijoDerecho(nuevoHijoDerecho);
                }
            }
            // si elem es menor o igual que el dato almacenado en la raiz
            else
            {
                // idem anterior en hijo izquierdo
                if (this.getHijoIzquierdo() == null)
                {
                    this.agregarHijoIzquierdo((AVL)elem);
                }
                else
                {
                    AVL nuevoHijoIzquierdo = this.getHijoIzquierdo().agregar(elem);
                    this.agregarHijoIzquierdo(nuevoHijoIzquierdo);
                }
            }

            // actualizar altura
            this.actualizarAltura();

            // control de desbalance
            AVL nuevaRaiz = this;
            int balance   = this.calcularDesbalance();

            if (balance >= 2)                   // desbalance del lado derecho
            {
                // si elem es mayor que hijo derecho, entonces rotacion simple con derecho
                if (elem.CompareTo(this.getHijoDerecho()) > 0)
                {
                    nuevaRaiz = this.rotacionSimpleDerecha();
                }
                // si elem es menor o igual, entonces rotacion doble con derecho
                else
                {
                    nuevaRaiz = this.rotacionDobleDerecha();
                }
            }

            if (balance <= -2)                  // desbalance del lado izquierdo
            {
                // si elem es menor que hijo izquierdo, entonces rotacion simple con izquierdo
                if (elem.CompareTo(this.getHijoIzquierdo()) <= 0)
                {
                    nuevaRaiz = this.rotacionSimpleIzquierda();
                }
                // si elem es mayor, entonces rotacion doble con izquierdo
                else
                {
                    nuevaRaiz = this.rotacionDobleIzquierda();
                }
            }

            return(nuevaRaiz);
        }
 public void eliminarHijoDerecho()
 {
     this.hijoDerecho = null;
 }
 public void eliminarHijoIzquierdo()
 {
     this.hijoIzquierdo = null;
 }
 public void agregarHijoDerecho(AVL hijo)
 {
     this.hijoDerecho = hijo;
 }
 public void agregarHijoIzquierdo(AVL hijo)
 {
     this.hijoIzquierdo = hijo;
 }