UNIT uListaDin;

    INTERFACE
        USES uElem;
        TYPE
            TLista = ^TNodo;

            TNodo = RECORD
                info : TElemento;
                sig : TLista;
            END; {TNodo}

        PROCEDURE CrearLista (VAR listaSP:TLista);


        FUNCTION ListaVacia (listaSP:TLista):boolean;


        PROCEDURE ConstruirLista (VAR listaSP:TLista; elementoSP:TElemento);


        PROCEDURE Cabecera (listaSP:TLista; VAR cabeza:TElemento);


        PROCEDURE Resto (VAR listaSP:TLista);


        FUNCTION Longitud (listaSP:TLista):integer;


        FUNCTION Pertenece (listaSP:TLista; elementoSP:TElemento):boolean;


        PROCEDURE Concatenar (VAR listaSP1:TLista; listaSP2:TLista);


        PROCEDURE BorrarElemento (VAR listaSP:TLista; elementoSP:TElemento);


        PROCEDURE InsertarFinal (VAR listaSP:TLista; elementoSP:TElemento);


        PROCEDURE Ultimo (listaSP:TLista; VAR ultSP:TElemento);


        PROCEDURE EscribirLista (listaSP:TLista);

    IMPLEMENTATION

        PROCEDURE CrearLista (VAR listaSP:TLista);
            BEGIN
                listaSP := NIL;
            END;{CrearLista}

        FUNCTION ListaVacia (listaSP:TLista):boolean;
            BEGIN
                ListaVacia := (listaSP = NIL);
            END;{ListaVacia}

        PROCEDURE ConstruirLista (VAR listaSP:TLista; elementoSP:TElemento);
            VAR
                aux : TLista;
            BEGIN
                new(aux);
                Asignar(aux^.info,elementoSP);
                aux^.sig := listaSP;
                listaSP := aux;
            END;{ConstruirLista}

        PROCEDURE Cabecera (listaSP:TLista; VAR cabeza:TElemento);
            BEGIN
                Asignar(cabeza , listaSP^.info);
            END;{Cabecera}

        PROCEDURE Resto (VAR listaSP:TLista);
            VAR
                aux : TLista;
            BEGIN
                IF listaSP<>NIL THEN
                    BEGIN
                        aux := listaSP;
                        listaSP := listaSP^.sig;
                        dispose(listaSP);
                        listaSP := aux;
                    END;{IF}
            END;{Resto}

        FUNCTION Longitud (listaSP:TLista):integer;
            VAR
                i:integer;
            BEGIN
                IF listaSP = NIL THEN
                    Longitud := 0
                ELSE
                    i := 0;
                    WHILE listaSP <> NIL DO
                        BEGIN
                            i := succ(i);
                            listaSP := listaSP^.sig;
                        END;{WHILE}

                Longitud := i;
            END;{Longitud}

        FUNCTION Pertenece (listaSP:TLista; elementoSP:TElemento):boolean;
            VAR
                check:boolean;
            BEGIN
                check := FALSE;

                WHILE (listaSP<>NIL) AND (check=FALSE) DO
                    BEGIN
                        check := Igual(listaSP^.info , elementoSP);
                        listaSP := listaSP^.sig;
                    END;

                Pertenece := check;
            END;{Pertenece}

        PROCEDURE Concatenar (VAR listaSP1:TLista; listaSP2:TLista); {Concatena, a la listaSP1, la lista SP2}
                VAR
                    aux:TLista;
                BEGIN

                    IF listaSP1<>NIL THEN
                        BEGIN
                            aux := listaSP1;

                            WHILE aux^.sig<>NIL DO
                                aux := aux^.sig;


                            aux^.sig := listaSP2;
                        END
                    ELSE
                        listaSP1 := listaSP2; {Si listaSP1 es vacía, listaSP1 es igual a listaSP2}


                END;{Concatenar}

        PROCEDURE BorrarElemento (VAR listaSP:TLista; elementoSP:TElemento);
            VAR
                act,ant:TLista;
            BEGIN
                ant := NIL;
                act := listaSP;

                WHILE (act<>NIL) AND (listaSP^.info<>elementoSP) DO
                    BEGIN
                        ant := act;
                        act := act^.sig;
                    END;{WHILE}

                IF (act<>NIL) THEN
                    IF (ant = NIL) THEN
                        Resto(listaSP)
                    ELSE
                        BEGIN
                            ant^.sig := act^.sig;
                            dispose(act);
                        END;{ELSE}

            END;{BorrarElemento}

        PROCEDURE InsertarFinal (VAR listaSP:TLista; elementoSP:TElemento);
            VAR
                aux2,aux:TLista;
            BEGIN
                IF listaSP=NIL THEN
                    ConstruirLista(listaSP,elementoSP)
                ELSE
                    BEGIN
                        aux2:=listaSP;
                        new(aux);
                        Asignar(aux^.info,elementoSP);
                        aux^.sig := NIL;
                        WHILE aux2^.sig<>NIL DO
                            aux2 := aux2^.sig;
                        aux2^.sig := aux;
                    END;
            END;{InsertarFinal}

        PROCEDURE Ultimo (listaSP:TLista; VAR ultSP:TElemento);

            BEGIN
                IF listaSP<>NIL THEN
                    BEGIN

                        WHILE listaSP^.sig<>NIL DO
                            listaSP := listaSP^.sig;

                        Asignar(ultSP , listaSP^.info);

                    END;

            END;{Ultimo}

        PROCEDURE EscribirLista (listaSP:TLista);
            BEGIN
                WHILE listaSP<>NIL DO
                    BEGIN
                        writeln(listaSP^.info);
                        listaSP := listaSP^.sig;
                    END;{WHILE}
            END;{EscribirLista}


END.