MIRTA VARGAS DE ARGENTINA MEDIA 9 CALZADA Cat B 2° grupo 1ª Actividad
TLista
-
Upload
bryan-cevallos -
Category
Documents
-
view
212 -
download
0
description
Transcript of TLista
-
TLista.pas
(*--------------------------------------------------------------*)(* Mdulo: TLista *)(* Fichero: ()Programa (X)Espec.TAD (X) Impl. TAD (X) Otros *)(* Autor: *)(* Fecha: *)(* Descripcin: TAD TipoLista. Implementacin con lista *)(* enlazada simple. *)(*--------------------------------------------------------------*)
unit TLista;{------------------------------------------------------------------------}{ ESPECIFICACIN TAD TipoLista
PARAMETROS GENRICOSTIPO: TipoElementoOPERACIONES: SonElementosIguales: TipoElemento x TipoElemento -> Boolean
EsElementoMayor: TipoElemento x TipoElemento -> BooleanFIN PARAMETROS
OPERACIONES:
- CONSTRUCTORAS GENERADORAS: CrearVacia : -> TipoLista InsertarPrincipio: TipoElemento x TipoLista -> TipoLista
- OBSERVADORAS SELECTORAS: [parcial] Primero : TipoLista -> TipoElemento [parcial] Resto : TipoLista -> TipoLista [parcial] Enesimo: Integer x TipoLista -> TipoElemento [parcial] Ultimo: TipoLista -> TipoElemento
- OBSERVADORAS NO SELECTORAS: EsVacia : TipoLista -> booleano Longitud : TipoLista -> Integer Pertenece : TipoElemento x TipoLista -> Booleano Igual: TipoLista x TipoLista -> Booleano
- CONSTRUCTORAS NO GENERADORAS: Concatenar : TipoLista x TipoLista -> TipoLista Copiar : TipoLista -> TipoLista BorrarElemento : TipoElemento x TipoLista -> TipoLista InsertarFinal: TipoElemento x TipoLista -> TipoLista
VARIABLES:
lista, lista2: TipoLista; elemento: TipoElemento; posicion: TipoPosicion;
ECUACIONES:
CrearVacia() = lista Efecto: devuelve una lista con cero elementos
InsertarPrincipio(elemento, lista) = lista Efecto: Insterta por el principio un elemento en la lista.
Primero(lista) = elemento Requerimiento: la lista no puede estar vaca Efecto: devuelve el primer elemento de la lista
Resto(lista) = lista2 Requerimiento: la lista no puede estar vaca Efecto: devuelve lista2, que es el resto de la lista que
Page 1
-
TLista.pas
hay despus del primer elemento, sin modificar lista.
Ultimo(lista) = elemento Requerimiento: la lista no puede estar vaca Efecto: devuelve el ltimo elemento de la lista.
EsVacia(lista) = BOOLEANO Efecto: devuelve CIERTO si la lista no contiene ningn elemento y FALSO si contiene elementos.
Longitud(lista) = ENTERO Efecto: si la lista est vaca devuelve cero y si no, devuelve el nmero de elementos de la lista.
Pertenece(elemento, lista) = BOOLEANO Requisito: TipoElemento debe poseer la operacin comparacin de dos elementos. Efecto: si elemento es igual a algn elemento de la lista devuelve CIERTO, y si no, devuelve FALSO.
Copiar(lista) = lista2 Efecto: devuelve lista2, que es igual a lista. Equivale al operador asignacin, que asigna lista a lista2.
Concatenar(lista, lista2) = listaEfecto: si lista es vaca devuelve la lista con los elementos de lista2, si lista2 es vaca devuelve lista sin modificar, y si ninguna es vaca devuelve lista modificada, con los elementos de lista seguidos por los de lista2 aadidos al final.
BorrarElemento (elemento, lista) = lista Efecto: si lista es vaca o si no se encuentra en ella el elemento, devuelve la lista sin modificar. Si no, si elemento se encuentra en la lista devuelve lista sin ese elemento.
InsertarFinal (elemento, lista) = lista Efecto: devuelve la lista modificada, con el elemento aadido al final.
Enesimo(posicion, lista) = elemento Efecto: devuelve el elemento situado en la posicin de la lista que indica posicin.
Igual(lista, lista2) = BOOLEANO Efecto: devuelve CIERTO si las listas lista y lista2 son iguales, y en caso contrario devuelve FALSO.
FIN ESPECIFICACIN TAD TipoLista}{-------------------------------------------------------------------------------------}INTERFACE {Definicin de la parte pblica}{-------------------------------------------------------------------------------------}
USES TElemento;
TYPE
TipoLista = ^TipoNodo; TipoNodo = RECORD dato : TipoElemento; siguiente : TipoLista END; (* registro *)
PROCEDURE CrearVacia (VAR lista: TipoLista);(* POST: "Crea una lista sin elementos: []" *)
PROCEDURE InsertarPrincipio (elemento: TipoElemento; VAR lista: TipoLista);(* POST: "Construye una lista, dados un elemento y una lista *)
Page 2
-
TLista.pas
FUNCTION Primero (lista: TipoLista): TipoElemento;(* PRE: NOT EsVacia(lista) *)(* POST: resultado = "Primer elemento de una lista *)
FUNCTION Resto (lista: TipoLista):TipoLista;(* PRE: NOT EsVacia(lista) *)(* POST: "Devuelve la lista que sigue al primer elemento, sin modificar la lista*)
FUNCTION EsVacia (lista: TipoLista): BOOLEAN;(* POST: resultado = (lista = []) *)
FUNCTION Longitud (lista: TipoLista): INTEGER;(* POST: resultado = "numero de elementos de la lista" *)
FUNCTION Ultimo (lista: TipoLista): TipoElemento;(* PRE: NOT EsVacia(lista) *)(* POST: resultado = "elemento que ocupa la posicion final en la lista" *)
FUNCTION Pertenece (elemento: TipoElemento; lista: TipoLista): BOOLEAN;(* POST: resultado = (elemento EN lista) *)
PROCEDURE Copiar (lista: TipoLista; VAR lista2: TipoLista);(* POST: "devuelve lista2, que es igual a lista. Equivale al operador asignacin, que asigna lista a lista2." *)
PROCEDURE Concatenar (VAR lista: TipoLista; VAR lista2: Tipolista);(* POST: "lista3 toma el resultado de aadir al final de lista la estructura de lista2*)
PROCEDURE BorrarElemento (elemento: TipoElemento; VAR lista: TipoLista);(* POST: Elimina, si existe, la primera aparicion de elemento en lista *)
PROCEDURE InsertarFinal (elemento: TipoElemento; VAR lista: TipoLista);(* POST: Anyade el elemento haciendo que ocupe la ultima posicion de la lista *)
PROCEDURE Enesimo (posicion: Integer; lista: TipoLista; VAR elemento: TipoElemento);(* PRE: 1
-
TLista.pas
END;{--------------------------------------------------}FUNCTION Primero (lista: TipoLista): TipoElemento;(* PRE: NOT EsVacia(lista) *)(* POST: resultado = "Primer elemento de una lista *)(* COMPLEJIDAD: O(1) *)BEGIN
IF NOT EsVacia (lista) THEN Primero := lista^.dato ELSE WRITELN('Error en Function Primero: la lista es vaca.');END;{--------------------------------------------------------}FUNCTION Resto (lista: TipoLista): TipoLista;(* PRE: NOT EsVacia(lista) *)(* POST: "Devuelve la lista que sigue al primer elemento, sin modificar la lista*)(* COMPLEJIDAD: O(1) *)BEGIN
IF NOT EsVacia (lista) THEN Resto := lista^.siguiente ELSE WRITELN('Error en Function Resto: la lista es vaca.')END;{--------------------------------------------}FUNCTION EsVacia (lista: TipoLista): BOOLEAN;(* POST: resultado = (lista = []) *)(* COMPLEJIDAD: O(1) *)BEGIN
EsVacia := (lista = NIL)END;{---------------------------------------------}FUNCTION Longitud (lista: TipoLista): INTEGER;(* POST: resultado = "numero de elementos de la lista" *)(* COMPLEJIDAD: O(N), siendo N el numero de elementos de la lista *)VAR
long : integer; pAux : TipoLista;BEGIN
pAux := lista; long := 0; WHILE pAux NIL DO BEGIN long := long + 1; pAux := pAux^.siguiente END; Longitud := longEND;
(* NOTA: Funcin Longitud recursiva:
FUNCTION Longitud (lista: TipoLista): INTEGER;
BEGINIF EsVacia(lista) THEN
Longitud := 0ELSE
BEGINLongitud := 1 + Longitud(resto(lista))
END;END;*){------------------------------------------------}FUNCTION Ultimo (lista: TipoLista): TipoElemento;
Page 4
-
TLista.pas
(* PRE: NOT EsVacia(lista) *)(* POST: resultado = "elemento que ocupa la posicion final en la lista" *)(* COMPLEJIDAD: O(N) *)VAR
pAux : TipoLista;BEGIN
IF NOT EsVacia (lista) THEN {la lista tiene algn elemento} BEGIN pAux := lista; WHILE pAux^.siguiente NIL DO pAux := pAux^.siguiente; Ultimo := pAux^.dato END ELSE WRITELN('Error en Function Ultimo: la lista es vaca' )END;{------------------------------------------------------------------------}FUNCTION Pertenece (elemento: TipoElemento; lista: TipoLista): BOOLEAN;(* POST: resultado = (elemento EN lista) *)(* COMPLEJIDAD: O(Longitud(lista)) *)VAR
pAux : TipoLista; esta : BOOLEAN;BEGIN
pAux := lista; esta := FALSE; WHILE (pAux NIL) AND NOT esta DO BEGIN IF SonElementosIguales(pAux^.dato, elemento) THEN (* NOTA: implementar esta operacin en el TAD parmetro TipoElemento, en vez usar directamente "pAux^.dato = elemento" proporciona genericidad al TAD TipoLista, que servir tanto si TipoElemento es simple como si es compuesto *) esta := TRUE ELSE pAux :=pAux^.siguiente END; Pertenece := estaEND;{-----------------------------------------------------------------------------------}PROCEDURE Copiar (lista: TipoLista; VAR lista2: TipoLista);(* POST: "Copia la lista en la estructura lista2" *)(* COMPLEJIDAD: O(Longitud(lista)) *)VAR
pAux, pUltimo2, nuevo: TipoLista;BEGIN
IF EsVacia (lista) THEN {lista es vaca} CrearVacia (lista2) ELSE BEGIN {lista tiene elementos} pAux := lista; new (nuevo); {caso especial: copia del primer elemento, lista2 lo apuntar} nuevo^.dato := pAux^.dato; nuevo^.siguiente := NIL; lista2 := nuevo; pUltimo2 := nuevo; (*pUltimo2 indica la posicin en lista2 del ltimo elemento copiado, necesario para aadirle el prximo elemento a copiar*) pAux := pAux^.siguiente; WHILE pAux NIL DO BEGIN {copia del resto de elementos} new (nuevo); nuevo^.dato := pAux^.dato;
Page 5
-
TLista.pas
nuevo^.siguiente := NIL; pUltimo2^.siguiente := nuevo; pUltimo2 := nuevo; pAux := pAux^.siguiente END ENDEND;{-----------------------------------------------------------------------------------}
PROCEDURE Concatenar (VAR lista: TipoLista; VAR lista2: Tipolista);(* POST: "se aade al final de lista la estructura lista2 y lista2 queda vaca*)(* COMPLEJIDAD: O(Longitud(lista)) *)VAR
pAux: TipoLista; (* punteros auxiliares para recorrido de 'lista' *)
BEGIN
IF NOT EsVacia (lista2) THEN {lista2 no es vaca} IF EsVacia (lista) THEN lista := lista2 {lista es vaca pero lista2 no} ELSE BEGIN {lista y lista2 no son vacas} pAux := lista; {busco el puntero al ltimo elemento de lista para aadir ah lista2} WHILE pAux^.siguiente NIL DO pAux := pAux^.siguiente; pAux^.siguiente := lista2 {se aade lista2 al final de lista1}
END; lista2:= NIL;
END;{-----------------------------------------------------------------------------------}{NOTA: Vase la diferencia entre Concatenar y Concatenar2.}
PROCEDURE Concatenar2 (lista, lista2: Tipolista; VAR lista3: TipoLista);(* POST: "lista3 toma como resultado una copia de lista seguida de una copia de lista2 COMPLEJIDAD: O(Longitud(lista)+Longitud(lista2)) *)VAR
pAct4, lista4 : TipoLista; (* punteros auxiliares para recorrido de 'lista' *)
BEGIN
IF EsVacia (lista) THEN {lista es vaca} IF EsVacia (lista2) THEN CrearVacia (lista3) {lista y lista2 son vacas -> lista3 ser vaca} ELSE Copiar (lista2, lista3) {lista es vaca pero lista2 no -> lista3 ser lista2} ELSE {lista no es vaca} IF EsVacia (lista2) THEN Copiar (lista, lista3) {lista no es vaca pero lista2 s -> lista3 ser lista}
ELSE
BEGIN {lista y lista2 no son vacas} Copiar (lista2, lista3); {copio lista2 en lista3} Copiar (lista, lista4); {copio lista en lista4} pAct4 := lista4; WHILE pAct4^.siguiente NIL DO {busco el puntero al ltimo elemento de lista4 para aadir ah lista3} BEGIN pAct4 := pAct4^.siguiente END; pAct4^.siguiente := lista3; lista3 := lista4
END
END;
Page 6
-
TLista.pas
{-----------------------------------------------------------------------------------}PROCEDURE BorrarElemento (elemento: TipoElemento; VAR lista: TipoLista);(* POST: Elimina, si existe, la primera aparicion de elemento en lista. Si la lista est vacael resultado es la lista vaca *)(* COMPLEJIDAD: O(Longitud(lista)) *)VAR
pAct, pAnt: TipoLista; encontrado: boolean;
BEGIN
encontrado := FALSE;
IF NOT EsVacia (lista) THEN BEGIN pAct := lista; pAnt := NIL;
WHILE (pAct NIL) AND (NOT encontrado) DO (*bsqueda de la 1 aparicin del elemento*) BEGIN IF SonElementosIguales(pAct^.dato, elemento) THEN (* NOTA: implementar esta operacin en el TAD parmetro TipoElemento, en vez usar directamente "pAct^.dato = elemento" proporciona genericidad al TAD TipoLista, que servir tanto si TipoElemento es simple como si es compuesto *) encontrado := TRUE ELSE BEGIN pAnt := pAct; pAct := pAct^.siguiente END END; (* end while*)
IF encontrado THEN (* elemento encontrado -> eliminacin*) IF (pAnt = NIL) THEN (*es el primer elemento de la lista: hay que modificar lista *)
IF (pAct^.siguiente = NIL) THEN (* la lista tiene slo un elemento *)BEGIN
dispose(lista);lista := NIL
END
ELSE (* la lista tiene ms de un elemento *)BEGIN
lista := pAct^.siguiente;dispose(pAct);
END
ELSE (* no es el primer elemento *) BEGIN (* se hace igual tanto si es el ltimo como si es uno central *)
pAnt^.siguiente := pAct^.siguiente; Dispose (pAct) END END {end IF NOT EsVacia(lista)}END; {end procedure}{-----------------------------------------------------------------------------------}PROCEDURE InsertarFinal (elemento: TipoElemento; VAR lista: TipoLista);(* COMPLEJIDAD: O(Longitud(lista)= O(N)) *)VAR
pAct: TipoLista; nuevo: TipoLista; (* nuevo nodo a aadir al final de la lista*)BEGIN
Page 7
-
TLista.pas
IF EsVacia (lista) THEN InsertarPrincipio (elemento, lista) ELSE BEGIN pAct := lista; WHILE pAct^.siguiente NIL DO pAct := pAct^.siguiente;
New (nuevo); nuevo^.dato := elemento; nuevo^.siguiente := NIL; pAct^.siguiente := nuevo ENDEND;{-----------------------------------------------------------------------------------}PROCEDURE Enesimo (posicion: Integer; lista: TipoLista; VAR elemento: TipoElemento);(* PRE: 1
-
TLista.pas
end.
Page 9