UNIT uListaOrd;

INTERFACE
USES uElem;

    TYPE
        TListaOrd = ^TNodo;

        TNodo = RECORD
            info:TElem;
            sig:TListaOrd;
        END;

    PROCEDURE CrearListaVacia (VAR lista:TListaOrd);

    PROCEDURE Insertar (VAR lista:TListaOrd; elem:TElem);

    PROCEDURE Resto (VAR lista:TListaOrd);

    FUNCTION EsListaVacia (lista:TListaOrd):boolean;

    PROCEDURE InsertarFinal (VAR lista:TListaOrd; elem:TElem);

    PROCEDURE MostrarLista (lista:TListaOrd);

    FUNCTION Pertenece (lista:TListaOrd; elem:TElem):boolean;

    PROCEDURE Avanzar (VAR lista:TListaOrd);

    PROCEDURE BorrarLista (VAR lista:TListaOrd);

IMPLEMENTATION

    PROCEDURE CrearListaVacia (VAR lista:TListaOrd);
        BEGIN
            lista := NIL;
        END;{CrearListaVacia}

    PROCEDURE Insertar (VAR lista:TListaOrd; elem:TElem);
        VAR
            aux,ant,act:TListaOrd;
        BEGIN
            IF EsListaVacia(lista) THEN
                BEGIN
                    new(aux);
                    Asignar(aux^.info,elem);
                    CrearListaVacia(aux^.sig);
                    lista := aux;
                END {IF}
            ELSE
                BEGIN
                    IF NOT(Pertenece(lista,elem)) THEN
                        ant := NIL;
                        act := lista;

                        WHILE NOT(EsListaVacia(act)) AND ( MayorQue(act^.info,elem)=FALSE ) DO
                            BEGIN
                                ant := act;
                                act := act^.sig;
                            END;{WHILE}

                        IF act=NIL THEN {Si el bucle llega hasta el final, eso es que el elemento es mayor que el mayor de la lista}
                            InsertarFinal(ant^.sig,elem);

                        IF act=lista THEN {Si act=lista eso quiere decir que no ha entrado en el bucle y eso quiere decir que el elemento es más pequeño que el más pequeño de la lista}
                            BEGIN
                                new(aux);
                                Asignar(aux^.info,elem);
                                aux^.sig := lista;
                                lista := aux;
                            END;{IF}

                        IF (ant <> NIL) AND (act <> NIL) THEN
                            BEGIN
                                new(aux);
                                Asignar(aux^.info,elem);
                                aux^.sig := act;
                                ant^.sig := aux;
                            END;{IF}
                END; {ELSE}
        END;{Insertar}

    PROCEDURE Resto (VAR lista:TListaOrd);
        VAR
            aux:TListaOrd;
        BEGIN
            IF NOT(EsListaVacia(lista)) THEN
                BEGIN
                    aux := lista;
                    lista := lista^.sig;
                    dispose(aux);
                END;{IF}

        END;{Resto}

    FUNCTION EsListaVacia (lista:TListaOrd):boolean;
        BEGIN
            EsListaVacia := (lista = NIL);
        END;{EsListaVacia}

    PROCEDURE InsertarFinal (VAR lista:TListaOrd; elem:TElem);
        VAR
            apunt,aux:TListaOrd;
        BEGIN
            IF EsListaVacia(lista) THEN
                Insertar(lista,elem)
            ELSE
                BEGIN
                    apunt := lista;
                    WHILE NOT(EsListaVacia(apunt^.sig)) DO
                        BEGIN
                            Avanzar(apunt);
                        END;{WHILE}
                    new(aux);
                    Asignar(aux^.info,elem);
                    aux^.sig := NIL;
                    apunt^.sig := aux;

                END;{Else}

        END;{InsertarFinal}

    PROCEDURE MostrarLista (lista:TListaOrd);
        BEGIN
            WHILE NOT(EsListaVacia(lista)) DO
                BEGIN
                    MostrarElem(lista^.info);
                    Avanzar(lista);
                END;{WHILE}
        END;{MostrarLista}

    FUNCTION Pertenece (lista:TListaOrd; elem:TElem):boolean;
        VAR
            check:boolean;
        BEGIN
            check := FALSE;
            IF NOT(EsListaVacia(lista)) THEN
                BEGIN

                    WHILE (NOT(EsListaVacia(lista))) AND ( MayorIgual(lista^.info,elem)=FALSE ) DO
                        BEGIN
                            lista := lista^.sig;;
                        END;{WHILE}

                    IF (NOT(EsListaVacia(lista))) THEN
                        IF Iguales(elem,lista^.info) THEN
                            check := TRUE
                        ELSE
                            check := FALSE;
                END;{IF}
            Pertenece := check;
        END;{Pertenece}

    PROCEDURE Avanzar (VAR lista:TListaOrd);
        BEGIN
            lista := lista^.sig;
        END;{Avanzar}

    PROCEDURE BorrarLista (VAR lista:TListaOrd);
        BEGIN
            WHILE NOT(EsListaVacia(lista)) DO
                BEGIN
                    Resto(lista);
                    Avanzar(lista);
                END;{WHILE}

        END;{BorrarLista}

END.