prg pract 5 conjuntostring

/**
 * Clase ConjuntoString. Implementacion de un
 * conjunto de String mediante una secuencia
 * enlazada ordenada lexicograficamente.
 *
 * @author (PRG. ETSINF. UPV)
 * @version (Curso 2016/17)
 */
public class ConjuntoString {

    private NodoString primero;
    private int talla;

    /**
     * Crea un conjunto vacio.
     */
    public ConjuntoString() {
        primero = null;
        talla = 0;
    }

    /**
     * Inserta s en el conjunto.
     * Si s ya pertenece al conjunto, el conjunto no cambia.
     *
     * @param s String. Elemento que se inserta en el conjunto.
     */
    public void insertar(String s) {
        NodoString aux = primero,
                   ant = null;
        int a = -1;
        while(aux != null && a < 0 ) {
            a = aux.dato.compareTo(s);
            if (a < 0) {
                ant = aux;
                aux = aux.siguiente;
            }
        }
        if (a != 0) {
            talla++;
            if(aux == primero) { primero = new NodoString(s, primero); }
            else ant.siguiente = new NodoString(s, aux);
        }
    }

    /**
     * Comprueba si s pertenece al conjunto.
     *
     * @param s String.
     * @return true sii s pertenece al conjunto.
     */
    public boolean pertenece(String s) {
        NodoString aux = this.primero;
        boolean parar = false;
        while(aux != null && !parar) {
            parar = aux.dato.compareTo(s) >= 0;
            if(aux.dato.compareTo(s) == 0) { parar = true; }
            else aux = aux.siguiente;
        }
        if(aux == null) { return false; }
        else return aux.dato.equals(s);
    }



    /**
     * Elimina s del conjunto.
     * Si s no pertenece al conjunto, el conjunto no cambia.
     *
     * @param s String.
     */
    public void eliminar(String s) {
        NodoString aux = primero,
                   ant = null;
        int a = -1;
        while(aux != null && a < 0 ) {
            a = aux.dato.compareTo(s);
            if (a < 0) {
                ant = aux;
                aux = aux.siguiente;
            }
        }
        if (a == 0) {
            talla--;
            if(aux == primero) {
                primero = primero.siguiente;
            }
            else ant.siguiente = aux.siguiente;
        }
    }

    /**
     * Devuelve la talla o cardinal del conjunto.
     * @return la talla del conjunto.
     */
    public int talla() {
        return talla;
    }


    /**
     * Devuelve el conjunto interseccion del conjunto y de otro.
     *
     * @param otro ConjuntoString.
     * @return el conjunto interseccion.
     */
    public ConjuntoString interseccion(ConjuntoString otro) {
        ConjuntoString result = new ConjuntoString();
        NodoString aux1 = this.primero,
                   aux2 = otro.primero,
                   ultResult = null;
                   result.primero = null;
        result.talla = 0;
        while(result.primero == null && aux1 != null && aux2 != null) {
            if(aux1.dato.compareTo(aux2.dato) == 0){
                result.primero = new NodoString(aux1.dato);
                ultResult = result.primero;
                result.talla++;
                aux1 = aux1.siguiente;
                aux2 = aux2.siguiente;
            } else if (aux1.dato.compareTo(aux2.dato) < 0) {
                aux1 = aux1.siguiente;
            } else if (aux1.dato.compareTo(aux2.dato) > 0) {
                aux2 = aux2.siguiente;
            }
        }

        while(aux1 != null && aux2 != null){
            if(aux1.dato == aux2.dato){
                ultResult.siguiente = new NodoString(aux1.dato);
                ultResult = ultResult.siguiente;
                result.talla++;
                aux1 = aux1.siguiente;
                aux2 = aux2.siguiente;
            } else if (aux1.dato.compareTo(aux2.dato) < 0) {
                aux1 = aux1.siguiente;
            } else if (aux1.dato.compareTo(aux2.dato) > 0) {
                aux2 = aux2.siguiente;
            }
        }

        return result;
    }

    /**
     * Devuelve el conjunto union del conjunto y de otro.
     *
     * @param otro ConjuntoString.
     * @return el conjunto union.
     */
    public ConjuntoString union(ConjuntoString otro) {
        ConjuntoString result = new ConjuntoString();
        NodoString aux1 = this.primero,
                   aux2 = otro.primero,
                   ultResult = null;
                   result.primero = null;
        result.talla = 0;
        while(result.primero == null) {
            if(aux1 != null && aux2 != null && aux1.dato.compareTo(aux2.dato) == 0){
                result.primero = new NodoString(aux1.dato);
                ultResult = result.primero;
                result.talla++;
                aux1 = aux1.siguiente;
                aux2 = aux2.siguiente;
            } else if (aux2 == null || aux1.dato.compareTo(aux2.dato) < 0) {
                result.primero = new NodoString(aux1.dato);
                ultResult = result.primero;
                result.talla++;
                aux1 = aux1.siguiente;
            } else if (aux1 == null || aux1.dato.compareTo(aux2.dato) > 0) {
                result.primero = new NodoString(aux2.dato);
                ultResult = result.primero;
                result.talla++;
                aux2 = aux2.siguiente;
            }
        }

        while(aux1 != null && aux2 != null){
            if(aux1.dato == aux2.dato){
                ultResult.siguiente = new NodoString(aux1.dato);
                ultResult = ultResult.siguiente;
                result.talla++;
                aux1 = aux1.siguiente;
                aux2 = aux2.siguiente;
            } else if (aux1.dato.compareTo(aux2.dato) < 0) {
                ultResult.siguiente = new NodoString(aux1.dato);
                ultResult = ultResult.siguiente;
                result.talla++;
                aux1 = aux1.siguiente;
            } else if (aux1.dato.compareTo(aux2.dato) > 0) {
                ultResult.siguiente = new NodoString(aux2.dato);
                ultResult = ultResult.siguiente;
                result.talla++;
                aux2 = aux2.siguiente;
            }
        }

        if(aux1 == null && aux2 != null && ultResult != null){
            while (aux2 != null) {
                ultResult.siguiente = new NodoString(aux2.dato);
                ultResult = ultResult.siguiente;
                result.talla++;
                aux2 = aux2.siguiente;
            }
        }
        //falta si ultresult es null pero aun queda una cola con elementos
        if(aux2 == null && aux1 != null && ultResult != null){

            while (aux1 != null) {
                ultResult.siguiente = new NodoString(aux1.dato);
                ultResult = ultResult.siguiente;
                result.talla++;
                aux1 = aux1.siguiente;
            }
        }
        return result;

    }


    /**
     * Devuelve el listado de los Strings en el conjunto, en orden
     * lexicográfico, y separados por saltos de linea.
     * Si el conjunto es vacio devuelve "", la String vacia.
     *
     * @return el listado de los elementos del conjunto.
     */
    public String toString() {
        String result = "";
        NodoString aux = this.primero;
        while (aux != null) {
            result += aux.dato + "\n";
            aux = aux.siguiente;
        }
        return result;
    }

}