--- /dev/null
+unit apl_ab;\r
+\r
+{\r
+ IMPLEMENTACION : APLICACIONES ARBOLES BINARIOS\r
+ \r
+}\r
+interface\r
+\r
+uses tda_gral, arbol_bin;\r
+\r
+{ procesa todos los nodos de un arbol recursivamente en INORDEN}\r
+PROCEDURE APL_AB_recorrer_rec_in( a: AB_arbol);\r
+\r
+{ procesa todos los nodos de un arbol recursivamente en PREORDEN}\r
+PROCEDURE APL_AB_recorrer_rec_pre( a: AB_arbol);\r
+\r
+{ procesa todos los nodos de un arbol recursivamente en POSORDEN}\r
+PROCEDURE APL_AB_recorrer_rec_pos( a: AB_arbol);\r
+\r
+{ busca un elemento segun una clave determinada exhaustivamente (BUSQUEDA EXTERNA) RECURSIVO }\r
+PROCEDURE APL_AB_buscar_externo( VAR a: AB_arbol; e: Tipo_Elem; VAR error: boolean );\r
+\r
+implementation\r
+\r
+{ recorrer todos los nodos del arbol procesando todos los elementos }\r
+{ ORDEN de recorrido: INORDEN, o sea, izquierda, nodo, derecha }\r
+PROCEDURE APL_AB_recorrer_rec_in( a: AB_arbol);\r
+ PROCEDURE recorrer_rec( a: AB_arbol );\r
+ VAR\r
+ error: boolean;\r
+ e: Tipo_Elem;\r
+ BEGIN\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_izquierda, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+ AB_mover_cte( a, AB_padre, error );\r
+ END;\r
+ { proceso el nodo corriente }\r
+ AB_elem_cte( a, e);\r
+ Procesar_Elem_Recorrido( e );\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_derecha, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+{ AB_mover_cte( a, AB_padre, error ); no hace falta }\r
+ END;\r
+ END;\r
+VAR\r
+ error: boolean;\r
+BEGIN\r
+ { me voy a la raiz y desde allí proceso todo }\r
+ AB_mover_cte( a, AB_raiz, error );\r
+ recorrer_rec( a );\r
+END;\r
+\r
+{ recorrer todos los nodos del arbol procesando todos los elementos }\r
+{ ORDEN de recorrido: PREORDEN, o sea, nodo, izquierda, derecha }\r
+PROCEDURE APL_AB_recorrer_rec_pre( a: AB_arbol);\r
+ PROCEDURE recorrer_rec( a: AB_arbol );\r
+ VAR\r
+ error: boolean;\r
+ e: Tipo_Elem;\r
+ BEGIN\r
+ { proceso el nodo corriente }\r
+ AB_elem_cte( a, e);\r
+ Procesar_Elem_Recorrido( e );\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_izquierda, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+ AB_mover_cte( a, AB_padre, error );\r
+ END;\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_derecha, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+{ AB_mover_cte( a, AB_padre, error ); no hace falta }\r
+ END;\r
+ END;\r
+VAR\r
+ error: boolean;\r
+BEGIN\r
+ { me voy a la raiz y desde allí proceso todo }\r
+ AB_mover_cte( a, AB_raiz, error );\r
+ recorrer_rec( a );\r
+END;\r
+\r
+{ recorrer todos los nodos del arbol procesando todos los elementos }\r
+{ ORDEN de recorrido: POSORDEN, o sea, izquierda, derecha, nodo }\r
+PROCEDURE APL_AB_recorrer_rec_pos( a: AB_arbol);\r
+ PROCEDURE recorrer_rec( a: AB_arbol );\r
+ VAR\r
+ error: boolean;\r
+ e: Tipo_Elem;\r
+ BEGIN\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_izquierda, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+ AB_mover_cte( a, AB_padre, error );\r
+ END;\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_derecha, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+ AB_mover_cte( a, AB_padre, error );\r
+ END;\r
+ { proceso el nodo corriente }\r
+ AB_elem_cte( a, e);\r
+ Procesar_Elem_Recorrido( e );\r
+ END;\r
+VAR\r
+ error: boolean;\r
+BEGIN\r
+ { me voy a la raiz y desde allí proceso todo }\r
+ AB_mover_cte( a, AB_raiz, error );\r
+ recorrer_rec( a );\r
+END;\r
+\r
+{ busca un elemento segun una clave determinada exhaustivamente (BUSQUEDA EXTERNA) }\r
+PROCEDURE APL_AB_buscar_externo( VAR a: AB_arbol; e: Tipo_Elem; VAR error: boolean );\r
+ FUNCTION buscar_rec( VAR a: AB_arbol; e: Tipo_Elem): boolean;\r
+ VAR\r
+ d: Tipo_Elem;\r
+ resultado: boolean;\r
+ BEGIN\r
+ { proceso el nodo corriente }\r
+ AB_elem_cte( a, e);\r
+ resultado := Comparar_Elementos( e, d );\r
+ IF NOT resultado\r
+ THEN BEGIN\r
+ { no era el buscado }\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_izquierda, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ resultado := buscar_rec( a, e );\r
+ IF NOT resultado\r
+ THEN BEGIN\r
+ { proceso el subarbol izquierdo }\r
+ AB_mover_cte( a, AB_padre, error );\r
+ AB_mover_cte( a, AB_derecha, error );\r
+ IF not error\r
+ THEN BEGIN\r
+ resultado := buscar_rec( a, e );\r
+ IF NOT resultado\r
+ THEN\r
+ AB_mover_cte( a, AB_padre, error );\r
+ END;\r
+ END;\r
+ END;\r
+ END;\r
+ buscar_rec := resultado; \r
+ END;\r
+BEGIN\r
+ { me voy a la raiz y desde allí proceso todo }\r
+ AB_mover_cte( a, AB_raiz, error );\r
+ error := buscar_rec( a, e );\r
+END;\r
+\r
+end.\r
+\r
--- /dev/null
+unit apl_abo;\r
+\r
+{ \r
+ IMPLEMENTACION : APLICACIONES ARBOLES BINARIOS ORDENADOS \r
+ \r
+}\r
+interface\r
+\r
+uses tda_gral, arbol_bin_ord;\r
+\r
+{ procesa todos los nodos de un arbol recursivamente }\r
+PROCEDURE APL_ABO_recorrer_rec( a: ABO_arbol);\r
+\r
+implementation\r
+\r
+{ recorrer todos los nodos del arbol procesando todos los elementos }\r
+{ ORDEN de recorrido: como el contenedor ya esta ordenado se recorre en el orden definido para el orden }\r
+PROCEDURE APL_ABO_recorrer_rec( a: ABO_arbol);\r
+ PROCEDURE recorrer_rec( a: ABO_arbol );\r
+ VAR \r
+ error: boolean;\r
+ e: Tipo_Elem;\r
+ BEGIN\r
+ { proceso el subarbol izquierdo }\r
+ ABO_mover_cte( a, ABO_izquierda, error );\r
+ IF not error \r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+ ABO_mover_cte( a, ABO_padre, error );\r
+ END;\r
+ { proceso el nodo corriente }\r
+ ABO_elem_cte( a, e);\r
+ Procesar_Elem_Recorrido( e );\r
+ { proceso el subarbol izquierdo }\r
+ ABO_mover_cte( a, ABO_derecha, error );\r
+ IF not error \r
+ THEN BEGIN\r
+ recorrer_rec( a);\r
+{ ABO_mover_cte( a, ABO_padre, error ); no hace falta }\r
+ END;\r
+ END;\r
+VAR \r
+ error: boolean;\r
+BEGIN\r
+ { me voy a la raiz y desde allí proceso todo }\r
+ ABO_mover_cte( a, ABO_raiz, error );\r
+ recorrer_rec( a );\r
+END;\r
+\r
--- /dev/null
+unit arbol_bin;\r
+\r
+{\r
+ IMPLEMENTACION : ARBOLES BINARIOS\r
+ ALMACENAMIENTO : PUNTEROS\r
+ \r
+}\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ tipos propios del arbol binario }\r
+TYPE\r
+ AB_movimiento = ( AB_raiz, AB_izquierda, AB_derecha, AB_padre );\r
+\r
+ AB_puntero = ^AB_nodo;\r
+\r
+ AB_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Izquierda,\r
+ Derecha : AB_puntero;\r
+ END;\r
+\r
+ AB_arbol = RECORD\r
+ Raiz,\r
+ Corriente: AB_puntero;\r
+ END;\r
+\r
+PROCEDURE AB_crear( VAR a: AB_arbol );\r
+FUNCTION AB_vacio( a: AB_arbol): BOOLEAN;\r
+PROCEDURE AB_elem_cte( a: AB_arbol; VAR e: Tipo_Elem);\r
+PROCEDURE AB_modif_cte( VAR a: AB_arbol; e: Tipo_Elem);\r
+PROCEDURE AB_mover_cte( VAR a: AB_arbol; m: AB_movimiento; VAR error: BOOLEAN );\r
+PROCEDURE AB_borrar_sub( VAR a: AB_arbol; m: AB_movimiento );\r
+PROCEDURE AB_insertar( VAR a: AB_arbol; m: AB_movimiento; e: Tipo_Elem; VAR error: BOOLEAN );\r
+PROCEDURE AB_vaciar( VAR a: AB_arbol );\r
+PROCEDURE AB_copiar( a: AB_arbol; VAR b: AB_arbol );\r
+\r
+implementation\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE AB_crear( VAR a: AB_arbol );\r
+BEGIN\r
+ a.Raiz := NIL;\r
+ a.Corriente := NIL;\r
+END;\r
+\r
+FUNCTION AB_vacio( a: AB_arbol): BOOLEAN;\r
+BEGIN\r
+ AB_vacio := ( a.Raiz = NIL);\r
+END;\r
+\r
+PROCEDURE AB_elem_cte( a: AB_arbol; VAR e: Tipo_Elem);\r
+BEGIN\r
+ e := a.Corriente^.Elem;\r
+END;\r
+\r
+PROCEDURE AB_modif_cte( VAR a: AB_arbol; e: Tipo_Elem);\r
+BEGIN\r
+ a.Corriente^.Elem := e;\r
+END;\r
+\r
+PROCEDURE AB_mover_cte( VAR a: AB_arbol; m: AB_movimiento; VAR error: BOOLEAN );\r
+ FUNCTION buscar_padre( p: AB_puntero; h: AB_puntero ) : AB_puntero;\r
+ VAR\r
+ ret : AB_puntero;\r
+ BEGIN\r
+ ret := NIL;\r
+ IF ( p^.Izquierda = h ) OR ( p^.Derecha = h )\r
+ THEN\r
+ ret := p;\r
+ IF ( ret = NIL ) AND ( p^.Izquierda <> NIL )\r
+ THEN\r
+ ret := buscar_padre ( p^.Izquierda, h );\r
+ IF ( ret = NIL ) AND ( p^.Derecha <> NIL )\r
+ THEN\r
+ ret := buscar_padre ( p^.Derecha, h );\r
+ buscar_padre := ret;\r
+ END;\r
+BEGIN\r
+ error := FALSE;\r
+ CASE m OF\r
+ AB_raiz:\r
+ A.Corriente := a.Raiz;\r
+ AB_izquierda:\r
+ IF a.Corriente^.Izquierda = NIL\r
+ THEN\r
+ error := TRUE\r
+ ELSE\r
+ a.Corriente := A.Corriente^.Izquierda;\r
+ AB_derecha:\r
+ IF A.Corriente^.Derecha = NIL\r
+ THEN\r
+ error := TRUE\r
+ ELSE\r
+ a.Corriente := A.Corriente^.Derecha;\r
+ AB_padre:\r
+ IF a.Corriente = A.Raiz\r
+ THEN\r
+ error := TRUE\r
+ ELSE\r
+ a.Corriente := buscar_padre( a.Raiz, a.Corriente );\r
+ END;\r
+END;\r
+\r
+PROCEDURE AB_borrar_sub( VAR a: AB_arbol; m: AB_movimiento );\r
+ PROCEDURE liberar_subarbol( VAR p : AB_puntero );\r
+ BEGIN\r
+ IF p <> NIL\r
+ THEN BEGIN\r
+ liberar_subarbol( p^.Izquierda );\r
+ liberar_subarbol( p^.Izquierda );\r
+ DISPOSE ( p );\r
+ p := NIL;\r
+ END;\r
+ END;\r
+BEGIN\r
+ CASE m OF\r
+ AB_izquierda:\r
+ liberar_subarbol( a.Corriente^.Izquierda );\r
+ AB_derecha:\r
+ liberar_subarbol( a.Corriente^.Derecha );\r
+ END;\r
+END;\r
+\r
+PROCEDURE AB_insertar( VAR a: AB_arbol; m: AB_movimiento; e: Tipo_Elem; VAR error: BOOLEAN );\r
+VAR\r
+ p : AB_puntero;\r
+BEGIN\r
+ error := FALSE;\r
+ NEW( p );\r
+ p^.Izquierda := NIL;\r
+ p^.Derecha := NIL;\r
+ p^.Elem := e;\r
+ CASE m OF\r
+ AB_raiz:\r
+ IF a.Raiz = NIL\r
+ THEN\r
+ a.Raiz := p\r
+ ELSE\r
+ error := TRUE;\r
+ AB_izquierda:\r
+ IF a.Corriente^.Izquierda = NIL\r
+ THEN\r
+ a.Corriente^.Izquierda := p\r
+ ELSE\r
+ error := TRUE;\r
+ AB_derecha:\r
+ IF a.Corriente^.Derecha = NIL\r
+ THEN\r
+ a.Corriente^.Derecha := p\r
+ ELSE\r
+ error := TRUE;\r
+ AB_padre:\r
+ error := TRUE\r
+ END;\r
+\r
+ IF error = FALSE\r
+ THEN\r
+ a.Corriente := p\r
+ ELSE\r
+ dispose( p );\r
+\r
+END;\r
+\r
+PROCEDURE AB_vaciar( VAR a: AB_arbol );\r
+ PROCEDURE liberar_subarbol( VAR p : AB_puntero );\r
+ BEGIN\r
+ IF p <> NIL\r
+ THEN BEGIN\r
+ liberar_subarbol( p^.Izquierda );\r
+ liberar_subarbol( p^.Derecha );\r
+ DISPOSE ( p );\r
+ p := NIL;\r
+ END;\r
+ END;\r
+BEGIN\r
+ liberar_subarbol( a.Raiz );\r
+ a.Corriente := NIL;\r
+END;\r
+\r
+PROCEDURE AB_copiar( a : AB_arbol; VAR b : AB_arbol );\r
+ PROCEDURE copiar_subarbol( o : AB_puntero; VAR d : AB_puntero );\r
+ BEGIN\r
+ IF o <> NIL\r
+ THEN BEGIN\r
+ { tengo que copiar el nodo y llamar a la copia de los hijos }\r
+ { el procedimiento va modificando el d como viene por referencia }\r
+ NEW ( d );\r
+ d^.Elem := o^.Elem;\r
+ d^.Izquierda := NIL;\r
+ d^.Derecha := NIL;\r
+ copiar_subarbol( o^.Izquierda, d^.Izquierda );\r
+ copiar_subarbol( o^.Derecha , d^.Derecha );\r
+ END;\r
+ END;\r
+BEGIN\r
+ { tenemos que vaciar primero el arbol b (destino) }\r
+ AB_vaciar( b );\r
+ { ahora copiamos todo el arbol origen }\r
+ copiar_subarbol( a.Raiz, b.Raiz );\r
+ a.Corriente := a.Raiz;\r
+END;\r
+\r
+end.
\ No newline at end of file
--- /dev/null
+unit arbol_bin_ord;\r
+\r
+{\r
+ IMPLEMENTACION : ARBOLES BINARIOS ORDENADOS\r
+ ALMACENAMIENTO : PUNTEROS\r
+ RECORRIDOS : RECURSIVOS\r
+ \r
+}\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ tipos propios del arbol binario }\r
+type\r
+ ABO_movimiento = ( ABO_raiz, ABO_izquierda, ABO_derecha, ABO_padre );\r
+\r
+ ABO_puntero = ^ABO_nodo;\r
+\r
+ ABO_nodo = record\r
+ Elem : Tipo_Elem;\r
+ Izquierda,\r
+ Derecha : ABO_puntero;\r
+ end;\r
+\r
+ ABO_arbol = record\r
+ Raiz,\r
+ Corriente: ABO_puntero;\r
+ end;\r
+\r
+PROCEDURE ABO_crear( VAR a: ABO_arbol );\r
+FUNCTION ABO_vacio( a: ABO_arbol): boolean;\r
+PROCEDURE ABO_elem_cte( a: ABO_arbol; VAR e: Tipo_Elem );\r
+PROCEDURE ABO_modif_cte( VAR a: ABO_arbol; e: Tipo_Elem );\r
+PROCEDURE ABO_mover_cte( VAR a: ABO_arbol; m: ABO_movimiento; VAR error: boolean );\r
+PROCEDURE ABO_borrar_cte( VAR a: ABO_arbol );\r
+PROCEDURE ABO_insertar( VAR a: ABO_arbol; e: Tipo_Elem; VAR error: boolean );\r
+PROCEDURE ABO_buscar( VAR a: ABO_arbol; c: Tipo_Clave; VAR error: boolean );\r
+PROCEDURE ABO_vaciar( VAR a: ABO_arbol );\r
+PROCEDURE ABO_copiar( a : ABO_arbol; VAR b : ABO_arbol );\r
+\r
+implementation\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE ABO_crear( VAR a: ABO_arbol );\r
+ begin\r
+ a.Raiz := nil;\r
+ a.Corriente := nil;\r
+ end;\r
+\r
+FUNCTION ABO_vacio( a: ABO_arbol): boolean;\r
+ begin\r
+ ABO_vacio := ( a.Raiz = nil );\r
+ end;\r
+\r
+PROCEDURE ABO_elem_cte( a: ABO_arbol; VAR e: Tipo_Elem);\r
+ begin\r
+ e := a.Corriente^.Elem;\r
+ end;\r
+\r
+PROCEDURE ABO_modif_cte( VAR a: ABO_arbol; e: Tipo_Elem);\r
+ begin\r
+ a.Corriente^.Elem := e;\r
+ end;\r
+\r
+PROCEDURE ABO_mover_cte( VAR a: ABO_arbol; m: ABO_movimiento; VAR error: BOOLEAN );\r
+ FUNCTION buscar_padre( p: ABO_puntero; h: ABO_puntero ) : ABO_puntero;\r
+ var\r
+ ret : ABO_puntero;\r
+ begin\r
+ ret := nil;\r
+ if ( p^.Izquierda = h ) or ( p^.Derecha = h ) then\r
+ ret := p;\r
+ { busco ordenado, por eso pregunto por la clave }\r
+ if ( ret = nil ) and ( p^.Izquierda <> nil ) and\r
+ ( Devolver_Clave_Elem( h^.Elem ) < Devolver_Clave_Elem( p^.Elem ) )\r
+ then\r
+ ret := buscar_padre ( p^.Izquierda, h );\r
+ if ( ret = nil ) and ( p^.Derecha <> nil ) and\r
+ ( Devolver_Clave_Elem( h^.Elem ) > Devolver_Clave_Elem( p^.Elem ) )\r
+ then\r
+ ret := buscar_padre ( p^.Derecha, h );\r
+ buscar_padre := ret;\r
+ end;\r
+ begin\r
+ error := false;\r
+ case m of\r
+ ABO_raiz:\r
+ A.Corriente := a.Raiz;\r
+ ABO_izquierda:\r
+ if a.Corriente^.Izquierda = nil then\r
+ error := true\r
+ else\r
+ a.Corriente := A.Corriente^.Izquierda;\r
+ ABO_derecha:\r
+ if a.Corriente^.Derecha = nil then\r
+ error := true\r
+ else\r
+ a.Corriente := A.Corriente^.Derecha;\r
+ ABO_padre:\r
+ if a.Corriente = A.Raiz then\r
+ error := true\r
+ else\r
+ a.Corriente := buscar_padre( a.Raiz, a.Corriente );\r
+ end;\r
+ end;\r
+\r
+PROCEDURE ABO_borrar_cte( VAR a: ABO_arbol );\r
+ FUNCTION buscar_padre( p: ABO_puntero; h: ABO_puntero ) : ABO_puntero;\r
+ var\r
+ ret : ABO_puntero;\r
+ begin\r
+ ret := nil;\r
+ if ( p^.Izquierda = h ) or ( p^.Derecha = h ) then\r
+ ret := p;\r
+ { busco ordenado, por eso pregunto por la clave }\r
+ if ( ret = nil ) and ( p^.Izquierda <> nil ) and\r
+ ( Devolver_Clave_Elem( h^.Elem ) < Devolver_Clave_Elem( p^.Elem ) )\r
+ then\r
+ ret := buscar_padre( p^.Izquierda, h );\r
+ if ( ret = nil ) and ( p^.Derecha <> nil ) and\r
+ ( Devolver_Clave_Elem( h^.Elem ) > Devolver_Clave_Elem( p^.Elem ) )\r
+ then\r
+ ret := buscar_padre( p^.Derecha, h );\r
+ buscar_padre := ret;\r
+ end;\r
+ var\r
+ p : ABO_puntero;\r
+ h : ABO_puntero;\r
+ n : ABO_puntero;\r
+ begin\r
+\r
+ if a.Corriente^.Izquierda <> nil then begin\r
+ h := a.Corriente^.Izquierda;\r
+ if a.Corriente^.Derecha <> nil then begin\r
+ { busco el nodo mas a la derecha del subarbol izquierdo }\r
+ n := a.Corriente^.Izquierda;\r
+ while n^.Derecha <> nil do begin\r
+ n := n^.Derecha;\r
+ end;\r
+ { aca asigno el subarbol derecho a donde corresponde }\r
+ n^.Derecha := a.Corriente^.Derecha;\r
+ end;\r
+ end\r
+ else\r
+ h := a.Corriente^.Derecha;\r
+\r
+ p := buscar_padre( a.Raiz, a.Corriente );\r
+ if p <> nil then\r
+ { no soy la raiz }\r
+ if Devolver_Clave_Elem( p^.Elem ) > Devolver_Clave_Elem( h^.Elem ) then\r
+ p^.Izquierda := h\r
+ else\r
+ p^.Derecha := h\r
+ else\r
+ { soy la raiz, la tengo que cambiar al nuevo nodo }\r
+ a.Raiz := h;\r
+\r
+ dispose( a.Corriente );\r
+\r
+ if h <> nil then\r
+ a.Corriente := h\r
+ else\r
+ a.Corriente := p;\r
+ end;\r
+\r
+PROCEDURE ABO_insertar( VAR a: ABO_arbol; e: Tipo_Elem; VAR error: BOOLEAN );\r
+ PROCEDURE buscar_lugar( p: ABO_puntero; e: Tipo_Elem; VAR d: ABO_puntero);\r
+ begin\r
+ { devuelve NIL si el elemento ya existe en el arbol }\r
+ if Devolver_Clave_Elem( e ) = Devolver_Clave_Elem( p^.Elem ) then\r
+ d := nil\r
+ else\r
+ if Devolver_Clave_Elem( e ) < Devolver_Clave_Elem( p^.Elem ) then\r
+ if p^.Izquierda <> nil then\r
+ buscar_lugar( p^.Izquierda, e, d )\r
+ else\r
+ d := p\r
+ else\r
+ if p^.Derecha <> nil then\r
+ buscar_lugar( p^.Derecha, e, d )\r
+ else\r
+ d := p\r
+ end;\r
+ var\r
+ p : ABO_puntero;\r
+ x : ABO_puntero;\r
+ begin\r
+ error := false;\r
+ new( p );\r
+ p^.Izquierda := nil;\r
+ p^.Derecha := nil;\r
+ p^.Elem := e;\r
+\r
+ { si el arbol esta vacio inserto directamente }\r
+ if a.Raiz = nil then\r
+ a.Raiz := p\r
+ else begin\r
+ buscar_lugar( a.Raiz, e, x );\r
+ if x = nil then\r
+ error := true\r
+ else\r
+ if Devolver_Clave_Elem( e ) < Devolver_Clave_Elem( x^.Elem ) then\r
+ x^.Izquierda := p\r
+ else\r
+ x^.Derecha := p;\r
+ end;\r
+\r
+ if error = false then\r
+ a.Corriente := p\r
+ else\r
+ dispose( p );\r
+\r
+ end;\r
+\r
+PROCEDURE ABO_buscar( VAR a: ABO_arbol; c: Tipo_Clave; VAR error: BOOLEAN );\r
+ PROCEDURE buscar_lugar( p: ABO_puntero; c: Tipo_Clave; VAR d: ABO_puntero);\r
+ begin\r
+ { devuelve NIL si el elemento NO existe en el arbol }\r
+ if c = Devolver_Clave_Elem( p^.Elem ) then\r
+ d := p\r
+ else\r
+ if c < Devolver_Clave_Elem( p^.Elem ) then\r
+ if p^.Izquierda <> nil then\r
+ buscar_lugar( p^.Izquierda, c, d )\r
+ else\r
+ d := nil\r
+ else\r
+ if p^.Derecha <> nil then\r
+ buscar_lugar( p^.Derecha, c, d )\r
+ else\r
+ d := nil\r
+ end;\r
+ var\r
+ x : ABO_puntero;\r
+\r
+ begin\r
+ error := false;\r
+ buscar_lugar( a.Raiz, c, x );\r
+ if x = nil then\r
+ { no encontro el elemento en el arbol }\r
+ error := true\r
+ else\r
+ a.Corriente := x;\r
+ end;\r
+\r
+PROCEDURE ABO_vaciar( VAR a: ABO_arbol );\r
+ PROCEDURE liberar_subarbol( VAR p : ABO_puntero );\r
+ begin\r
+ if p <> nil then begin\r
+ liberar_subarbol( p^.Izquierda );\r
+ liberar_subarbol( p^.Derecha );\r
+ dispose( p );\r
+ p := nil;\r
+ end;\r
+ end;\r
+ begin\r
+ liberar_subarbol( a.Raiz );\r
+ a.Corriente := nil;\r
+ end;\r
+\r
+PROCEDURE ABO_copiar( a : ABO_arbol; VAR b : ABO_arbol );\r
+ PROCEDURE copiar_subarbol( o : ABO_puntero; VAR d : ABO_puntero );\r
+ begin\r
+ if o <> nil then begin\r
+ { tengo que copiar el nodo y llamar a la copia de los hijos }\r
+ { el procedimiento va modificando el d como viene por referencia }\r
+ new( d );\r
+ d^.Elem := o^.Elem;\r
+ d^.Izquierda := nil;\r
+ d^.Derecha := nil;\r
+ copiar_subarbol( o^.Izquierda, d^.Izquierda );\r
+ copiar_subarbol( o^.Derecha , d^.Derecha );\r
+ end;\r
+ end;\r
+ begin\r
+ { tenemos que vaciar primero el arbol b (destino) }\r
+ ABO_vaciar( b );\r
+ { ahora copiamos todo el arbol origen }\r
+ copiar_subarbol( a.Raiz, b.Raiz );\r
+ a.Corriente := a.Raiz;\r
+ end;\r
+\r
+end.\r
--- /dev/null
+unit T_COLAC;\r
+\r
+{\r
+ IMPLEMENTACION : colas\r
+ ALMACENAMIENTO : CURSORES\r
+ \r
+}\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const COLAC_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+TYPE\r
+ COLAC_puntero = integer;\r
+\r
+const\r
+ COLAC_nulo : COLAC_puntero = 0;\r
+\r
+type\r
+\r
+ COLAC_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : COLAC_puntero;\r
+ END;\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ COLAC_Almac = record\r
+ almacenamiento : array [ 1 .. COLAC_MAX_CURSOR ] of COLAC_Nodo;\r
+ disponibles : array [ 1 .. COLAC_MAX_CURSOR ] of COLAC_Puntero;\r
+ primero_dispo : COLAC_Puntero;\r
+ end;\r
+\r
+ \r
+ COLAC_Cola = RECORD\r
+ almac : COLAC_Almac;\r
+ primero: COLAC_puntero;\r
+ ultimo : COLAC_puntero;\r
+ END;\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE COLAC_Inicializar( VAR l: COLAC_Cola );\r
+FUNCTION COLAC_vacio( l: COLAC_Cola): BOOLEAN;\r
+FUNCTION COLAC_lleno( l: COLAC_Cola): BOOLEAN;\r
+\r
+PROCEDURE COLAC_poner( VAR l: COLAC_Cola; e: Tipo_Elem );\r
+PROCEDURE COLAC_sacar( VAR l: COLAC_Cola; VAR e: Tipo_Elem);\r
+PROCEDURE COLAC_vaciar( VAR l: COLAC_Cola );\r
+PROCEDURE COLAC_copiar( a: COLAC_Cola; VAR b: COLAC_Cola );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure COLAC_Almac_Inicializar( VAR almac : COLAC_Almac );\r
+var i : COLAC_Puntero;\r
+begin\r
+ almac.primero_dispo := 1;\r
+ for i := 1 to COLAC_MAX_CURSOR - 1 do\r
+ begin\r
+ almac.disponibles[i] := i + 1;\r
+ end;\r
+ almac.disponibles[COLAC_MAX_CURSOR] := COLAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function COLAC_Almac_HayLugar( almac : COLAC_Almac ): boolean;\r
+begin\r
+ COLAC_Almac_HayLugar := almac.primero_dispo <> COLAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure COLAC_Almac_Reservar( VAR almac : COLAC_Almac; VAR puntero : COLAC_Puntero );\r
+begin\r
+ if not COLAC_Almac_HayLugar( almac )\r
+ then\r
+ puntero := COLAC_Nulo\r
+ else begin\r
+ puntero := almac.primero_dispo;\r
+ almac.primero_dispo := almac.disponibles[ puntero ];\r
+ end;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure COLAC_Almac_Liberar( VAR almac : COLAC_Almac; VAR puntero : COLAC_Puntero );\r
+begin\r
+ almac.disponibles[ puntero ] := almac.primero_dispo;\r
+ almac.primero_dispo := puntero;\r
+ puntero := COLAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure COLAC_Almac_Acceder( almac : COLAC_Almac; puntero : COLAC_Puntero; VAR elemento : COLAC_Nodo );\r
+begin\r
+ elemento := almac.almacenamiento[ puntero ];\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure COLAC_Almac_Modificar( VAR almac : COLAC_Almac; puntero : COLAC_Puntero; elemento : COLAC_Nodo );\r
+begin\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE COLAC_Inicializar( VAR l: COLAC_Cola );\r
+BEGIN\r
+ COLAC_Almac_Inicializar( l.almac );\r
+ l.primero := COLAC_Nulo;\r
+ l.ultimo := COLAC_Nulo;\r
+END;\r
+\r
+FUNCTION COLAC_vacio( l: COLAC_Cola): BOOLEAN;\r
+BEGIN\r
+ COLAC_vacio := ( l.Primero = COLAC_Nulo);\r
+END;\r
+\r
+FUNCTION COLAC_lleno( l: COLAC_Cola): BOOLEAN;\r
+BEGIN\r
+ COLAC_lleno := not COLAC_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE COLAC_poner( VAR l: COLAC_Cola; e: Tipo_Elem);\r
+VAR\r
+ p : COLAC_puntero;\r
+ n : COLAC_Nodo;\r
+ np: COLAC_Puntero;\r
+ m : COLAC_Nodo;\r
+BEGIN\r
+ COLAC_Almac_Reservar( l.almac, np );\r
+ n.Elem := e;\r
+ n.sig := COLAC_Nulo;\r
+ COLAC_Almac_Modificar( l.almac, np, n );\r
+ \r
+ if l.ultimo <> COLAC_Nulo then begin\r
+ { la cola no esta vacia, entonces tengo que modificar el ultimo }\r
+\r
+ { accedo al almacenamiento por el ultimo }\r
+ COLAC_Almac_Acceder( l.almac, l.ultimo, m );\r
+ m.sig := np;\r
+ COLAC_Almac_Modificar( l.almac, l.ultimo, m );\r
+ end\r
+ else\r
+ { si el ultimo es nulo significa que la cola esta vacia }\r
+ { pongo el primero al ultimo tambien }\r
+ l.primero := np;\r
+ l.ultimo := np;\r
+END;\r
+\r
+{ pre: no esta vacia }\r
+PROCEDURE COLAC_sacar( VAR l: COLAC_Cola; VAR e: Tipo_Elem);\r
+VAR n : COLAC_Nodo;\r
+ tmp : COLAC_Nodo;\r
+ tmpp: COLAC_Puntero;\r
+BEGIN\r
+ COLAC_Almac_Acceder( l.almac, l.primero, n );\r
+ COLAC_Almac_Liberar( l.almac, l.primero );\r
+ l.primero := n.Sig;\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+\r
+ if n.sig = COLAC_Nulo then\r
+ { la cola quedo vacia }\r
+ { el ultimo pasa a nulo, y el primero ya es nulo porque el siguiente de n era nulo }\r
+ l.ultimo := COLAC_Nulo;\r
+END;\r
+\r
+PROCEDURE COLAC_vaciar( VAR l: COLAC_Cola );\r
+VAR np : COLAC_Puntero;\r
+ n : COLAC_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> COLAC_Nulo ) do begin\r
+ COLAC_Almac_Acceder( l.almac, np, n );\r
+ COLAC_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := COLAC_Nulo;\r
+ l.ultimo := COLAC_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE COLAC_copiar( a : COLAC_Cola; VAR b : COLAC_Cola );\r
+VAR np, mp, tmpp : COLAC_Puntero;\r
+ n, m : COLAC_Nodo;\r
+BEGIN\r
+ if a.primero = COLAC_Nulo then exit;\r
+ np := a.primero;\r
+ COLAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ COLAC_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> COLAC_Nulo ) do begin\r
+\r
+ COLAC_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ COLAC_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ COLAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := COLAC_Nulo;\r
+ b.ultimo := mp;\r
+ COLAC_Almac_Modificar( b.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+unit T_LSC;\r
+\r
+{\r
+ IMPLEMENTACION : LISTAS SIMPLES\r
+ ALMACENAMIENTO : CURSORES\r
+ \r
+}\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const LSC_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+TYPE\r
+ LSC_puntero = integer;\r
+\r
+const\r
+ LSC_nulo : LSC_puntero = 0;\r
+\r
+type\r
+\r
+ LSC_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : LSC_puntero;\r
+ END;\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ LSC_Almac = record\r
+ almacenamiento : array [ 1 .. LSC_MAX_CURSOR ] of LSC_Nodo;\r
+ disponibles : array [ 1 .. LSC_MAX_CURSOR ] of LSC_Puntero;\r
+ primero_dispo : LSC_Puntero;\r
+ end;\r
+\r
+ \r
+ LSC_Lista = RECORD\r
+ almac : LSC_Almac;\r
+ primero: LSC_puntero;\r
+ corriente : LSC_puntero;\r
+ END;\r
+\r
+ LSC_movimiento = ( LSC_primero, LSC_siguiente );\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE LSC_Inicializar( VAR l: LSC_Lista );\r
+FUNCTION LSC_vacio( l: LSC_Lista): BOOLEAN;\r
+FUNCTION LSC_lleno( l: LSC_Lista): BOOLEAN;\r
+\r
+PROCEDURE LSC_elem_cte( l: LSC_Lista; VAR e: Tipo_Elem);\r
+PROCEDURE LSC_modif_cte( VAR l: LSC_Lista; e: Tipo_Elem);\r
+PROCEDURE LSC_mover_cte( VAR l: LSC_Lista; m: LSC_movimiento; VAR error: BOOLEAN );\r
+PROCEDURE LSC_borrar_cte( VAR l: LSC_Lista );\r
+PROCEDURE LSC_insertar( VAR l: LSC_Lista; m: LSC_movimiento; e: Tipo_Elem );\r
+PROCEDURE LSC_vaciar( VAR l: LSC_Lista );\r
+PROCEDURE LSC_copiar( a: LSC_Lista; VAR b: LSC_Lista );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure LSC_Almac_Inicializar( VAR almac : LSC_Almac );\r
+var i : LSC_Puntero;\r
+begin\r
+ almac.primero_dispo := 1;\r
+ for i := 1 to LSC_MAX_CURSOR - 1 do\r
+ begin\r
+ almac.disponibles[i] := i + 1;\r
+ end;\r
+ almac.disponibles[LSC_MAX_CURSOR] := LSC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function LSC_Almac_HayLugar( almac : LSC_Almac ): boolean;\r
+begin\r
+ LSC_Almac_HayLugar := almac.primero_dispo <> LSC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure LSC_Almac_Reservar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+begin\r
+ if not LSC_Almac_HayLugar( almac )\r
+ then\r
+ puntero := LSC_Nulo\r
+ else begin\r
+ puntero := almac.primero_dispo;\r
+ almac.primero_dispo := almac.disponibles[ puntero ];\r
+ end;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure LSC_Almac_Liberar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+begin\r
+ almac.disponibles[ puntero ] := almac.primero_dispo;\r
+ almac.primero_dispo := puntero;\r
+ puntero := LSC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure LSC_Almac_Acceder( almac : LSC_Almac; puntero : LSC_Puntero; VAR elemento : LSC_Nodo );\r
+begin\r
+ elemento := almac.almacenamiento[ puntero ];\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure LSC_Almac_Modificar( VAR almac : LSC_Almac; puntero : LSC_Puntero; elemento : LSC_Nodo );\r
+begin\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE LSC_Inicializar( VAR l: LSC_Lista );\r
+BEGIN\r
+ LSC_Almac_Inicializar( l.almac );\r
+ l.primero := LSC_Nulo;\r
+ l.corriente := LSC_Nulo;\r
+END;\r
+\r
+FUNCTION LSC_vacio( l: LSC_Lista): BOOLEAN;\r
+BEGIN\r
+ LSC_vacio := ( l.Primero = LSC_Nulo);\r
+END;\r
+\r
+FUNCTION LSC_lleno( l: LSC_Lista): BOOLEAN;\r
+BEGIN\r
+ LSC_lleno := not LSC_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE LSC_elem_cte( l: LSC_Lista; VAR e: Tipo_Elem);\r
+var n : LSC_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l.almac, l.Corriente, n );\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+END;\r
+\r
+PROCEDURE LSC_modif_cte( VAR l: LSC_Lista; e: Tipo_Elem);\r
+var n : LSC_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l.almac, l.Corriente, n );\r
+\r
+ { y la asigno al parametro }\r
+ n.Elem := e;\r
+\r
+ { y modifico el almacenamiento }\r
+ LSC_Almac_Modificar( l.almac, l.Corriente, n );\r
+\r
+END;\r
+\r
+PROCEDURE LSC_mover_cte( VAR l: LSC_Lista; m: LSC_movimiento; VAR error: BOOLEAN );\r
+VAR n : LSC_Nodo;\r
+BEGIN\r
+ error := FALSE;\r
+ CASE m OF\r
+ LSC_primero:\r
+ l.Corriente := l.Primero;\r
+ LSC_siguiente: begin\r
+\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l.almac, l.Corriente, n );\r
+ \r
+ IF n.sig = LSC_Nulo\r
+ THEN\r
+ error := TRUE\r
+ ELSE\r
+ l.corriente := n.sig;\r
+ end;\r
+ END;\r
+END;\r
+\r
+PROCEDURE LSC_borrar_cte( VAR l: LSC_Lista );\r
+VAR n : LSC_Nodo;\r
+ tmp : LSC_Nodo;\r
+ tmpp: LSC_Puntero;\r
+BEGIN\r
+ if l.corriente = l.primero then begin\r
+ LSC_Almac_Acceder( l.almac, l.primero, n );\r
+ l.primero := n.Sig;\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := l.primero;\r
+ end\r
+ else begin\r
+ tmpp := l.primero;\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+ while( tmp.sig <> l.corriente ) do begin\r
+ tmpp := tmp.sig;\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+ end;\r
+ LSC_Almac_Acceder( l.almac, l.corriente, n );\r
+ tmp.sig := n.Sig;\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := tmpp;\r
+ end;\r
+END;\r
+\r
+PROCEDURE LSC_insertar( VAR l: LSC_Lista; m: LSC_movimiento; e: Tipo_Elem );\r
+VAR\r
+ p : LSC_puntero;\r
+ n : LSC_Nodo;\r
+ np: LSC_Puntero;\r
+ an: LSC_Nodo;\r
+BEGIN\r
+ LSC_Almac_Reservar( l.almac, np );\r
+ n.Elem := e;\r
+ CASE m OF\r
+ LSC_primero: begin\r
+ n.sig := l.primero;\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+ l.primero := np;\r
+ end;\r
+ LSC_siguiente: begin\r
+ LSC_Almac_Acceder( l.almac, l.corriente, an );\r
+ n.sig := an.sig;\r
+ an.sig := np;\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+ LSC_Almac_Modificar( l.almac, l.corriente, an );\r
+ end;\r
+ END;\r
+\r
+ l.Corriente := np;\r
+\r
+END;\r
+\r
+PROCEDURE LSC_vaciar( VAR l: LSC_Lista );\r
+VAR np : LSC_Puntero;\r
+ n : LSC_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> LSC_Nulo ) do begin\r
+ LSC_Almac_Acceder( l.almac, np, n );\r
+ LSC_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := LSC_Nulo;\r
+ l.corriente := LSC_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE LSC_copiar( a : LSC_Lista; VAR b : LSC_Lista );\r
+VAR np, mp, tmpp : LSC_Puntero;\r
+ n, m : LSC_Nodo;\r
+BEGIN\r
+ if a.primero = LSC_Nulo then exit;\r
+ np := a.primero;\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+ LSC_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ b.corriente := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> LSC_Nulo ) do begin\r
+\r
+ LSC_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ LSC_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := LSC_Nulo;\r
+ LSC_Almac_Modificar( b.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+unit T_LSP;\r
+\r
+{\r
+ IMPLEMENTACION : LISTAS SIMPLES\r
+ ALMACENAMIENTO : PUNTERO\r
+ \r
+}\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const LSP_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+type\r
+\r
+ LSP_puntero = ^LSP_nodo;\r
+\r
+ LSP_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : LSP_puntero;\r
+ END;\r
+ \r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ LSP_Almac = record\r
+ end;\r
+\r
+ \r
+ LSP_Lista = RECORD\r
+ almac : LSP_Almac;\r
+ primero: LSP_puntero;\r
+ corriente : LSP_puntero;\r
+ END;\r
+\r
+ LSP_movimiento = ( LSP_primero, LSP_siguiente );\r
+\r
+const\r
+ LSP_nulo : LSP_puntero = nil;\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE LSP_Inicializar( VAR l: LSP_Lista );\r
+FUNCTION LSP_vacio( l: LSP_Lista): BOOLEAN;\r
+FUNCTION LSP_lleno( l: LSP_Lista): BOOLEAN;\r
+\r
+PROCEDURE LSP_elem_cte( l: LSP_Lista; VAR e: Tipo_Elem);\r
+PROCEDURE LSP_modif_cte( VAR l: LSP_Lista; e: Tipo_Elem);\r
+PROCEDURE LSP_mover_cte( VAR l: LSP_Lista; m: LSP_movimiento; VAR error: BOOLEAN );\r
+PROCEDURE LSP_borrar_cte( VAR l: LSP_Lista );\r
+PROCEDURE LSP_insertar( VAR l: LSP_Lista; m: LSP_movimiento; e: Tipo_Elem );\r
+PROCEDURE LSP_vaciar( VAR l: LSP_Lista );\r
+PROCEDURE LSP_copiar( a: LSP_Lista; VAR b: LSP_Lista );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure LSP_Almac_Inicializar( VAR almac : LSP_Almac );\r
+begin\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function LSP_Almac_HayLugar( almac : LSP_Almac ): boolean;\r
+begin\r
+ LSP_Almac_HayLugar := true;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure LSP_Almac_Reservar( VAR almac : LSP_Almac; VAR puntero : LSP_Puntero );\r
+begin\r
+ puntero := new( LSP_puntero );\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure LSP_Almac_Liberar( VAR almac : LSP_Almac; VAR puntero : LSP_Puntero );\r
+begin\r
+ dispose( puntero );\r
+ puntero := LSP_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure LSP_Almac_Acceder( almac : LSP_Almac; puntero : LSP_Puntero; VAR elemento : LSP_Nodo );\r
+begin\r
+ elemento := puntero^;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure LSP_Almac_Modificar( VAR almac : LSP_Almac; puntero : LSP_Puntero; elemento : LSP_Nodo );\r
+begin\r
+ puntero^ := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE LSP_Inicializar( VAR l: LSP_Lista );\r
+BEGIN\r
+ LSP_Almac_Inicializar( l.almac );\r
+ l.primero := LSP_Nulo;\r
+ l.corriente := LSP_Nulo;\r
+END;\r
+\r
+FUNCTION LSP_vacio( l: LSP_Lista): BOOLEAN;\r
+BEGIN\r
+ LSP_vacio := ( l.Primero = LSP_Nulo);\r
+END;\r
+\r
+FUNCTION LSP_lleno( l: LSP_Lista): BOOLEAN;\r
+BEGIN\r
+ LSP_lleno := not LSP_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE LSP_elem_cte( l: LSP_Lista; VAR e: Tipo_Elem);\r
+var n : LSP_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSP_Almac_Acceder( l.almac, l.Corriente, n );\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+END;\r
+\r
+PROCEDURE LSP_modif_cte( VAR l: LSP_Lista; e: Tipo_Elem);\r
+var n : LSP_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSP_Almac_Acceder( l.almac, l.Corriente, n );\r
+\r
+ { y la asigno al parametro }\r
+ n.Elem := e;\r
+\r
+ { y modifico el almacenamiento }\r
+ LSP_Almac_Modificar( l.almac, l.Corriente, n );\r
+\r
+END;\r
+\r
+PROCEDURE LSP_mover_cte( VAR l: LSP_Lista; m: LSP_movimiento; VAR error: BOOLEAN );\r
+VAR n : LSP_Nodo;\r
+BEGIN\r
+ error := FALSE;\r
+ CASE m OF\r
+ LSP_primero:\r
+ l.Corriente := l.Primero;\r
+ LSP_siguiente: begin\r
+\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSP_Almac_Acceder( l.almac, l.Corriente, n );\r
+ \r
+ IF n.sig = LSP_Nulo\r
+ THEN\r
+ error := TRUE\r
+ ELSE\r
+ l.corriente := n.sig;\r
+ end;\r
+ END;\r
+END;\r
+\r
+PROCEDURE LSP_borrar_cte( VAR l: LSP_Lista );\r
+VAR n : LSP_Nodo;\r
+ tmp : LSP_Nodo;\r
+ tmpp: LSP_Puntero;\r
+BEGIN\r
+ if l.corriente = l.primero then begin\r
+ LSP_Almac_Acceder( l.almac, l.primero, n );\r
+ l.primero := n.Sig;\r
+ LSP_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := l.primero;\r
+ end\r
+ else begin\r
+ tmpp := l.primero;\r
+ LSP_Almac_Acceder( l.almac, tmpp, tmp );\r
+ while( tmp.sig <> l.corriente ) do begin\r
+ tmpp := tmp.sig;\r
+ LSP_Almac_Acceder( l.almac, tmpp, tmp );\r
+ end;\r
+ LSP_Almac_Acceder( l.almac, l.corriente, n );\r
+ tmp.sig := n.Sig;\r
+ LSP_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := tmpp;\r
+ end;\r
+END;\r
+\r
+PROCEDURE LSP_insertar( VAR l: LSP_Lista; m: LSP_movimiento; e: Tipo_Elem );\r
+VAR\r
+ p : LSP_puntero;\r
+ n : LSP_Nodo;\r
+ np: LSP_Puntero;\r
+ an: LSP_Nodo;\r
+BEGIN\r
+ LSP_Almac_Reservar( l.almac, np );\r
+ n.Elem := e;\r
+ CASE m OF\r
+ LSP_primero: begin\r
+ n.sig := l.primero;\r
+ LSP_Almac_Modificar( l.almac, np, n );\r
+ l.primero := np;\r
+ end;\r
+ LSP_siguiente: begin\r
+ LSP_Almac_Acceder( l.almac, l.corriente, an );\r
+ n.sig := an.sig;\r
+ an.sig := np;\r
+ LSP_Almac_Modificar( l.almac, np, n );\r
+ LSP_Almac_Modificar( l.almac, l.corriente, an );\r
+ end;\r
+ END;\r
+\r
+ l.Corriente := np;\r
+\r
+END;\r
+\r
+PROCEDURE LSP_vaciar( VAR l: LSP_Lista );\r
+VAR np : LSP_Puntero;\r
+ n : LSP_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> LSP_Nulo ) do begin\r
+ LSP_Almac_Acceder( l.almac, np, n );\r
+ LSP_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := LSP_Nulo;\r
+ l.corriente := LSP_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE LSP_copiar( a : LSP_Lista; VAR b : LSP_Lista );\r
+VAR np, mp, tmpp : LSP_Puntero;\r
+ n, m : LSP_Nodo;\r
+BEGIN\r
+ if a.primero = LSP_Nulo then exit;\r
+ np := a.primero;\r
+ LSP_Almac_Acceder( a.almac, np, n );\r
+\r
+ LSP_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ b.corriente := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> LSP_Nulo ) do begin\r
+\r
+ LSP_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ LSP_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ LSP_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := LSP_Nulo;\r
+ LSP_Almac_Modificar( b.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+unit T_PILAC;\r
+\r
+{\r
+ IMPLEMENTACION : pilas\r
+ ALMACENAMIENTO : CURSORES\r
+ \r
+}\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const PILAC_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+TYPE\r
+ PILAC_puntero = integer;\r
+\r
+const\r
+ PILAC_nulo : PILAC_puntero = 0;\r
+\r
+type\r
+\r
+ PILAC_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : PILAC_puntero;\r
+ END;\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ PILAC_Almac = record\r
+ almacenamiento : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Nodo;\r
+ disponibles : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Puntero;\r
+ primero_dispo : PILAC_Puntero;\r
+ end;\r
+\r
+ \r
+ PILAC_Pila = RECORD\r
+ almac : PILAC_Almac;\r
+ primero: PILAC_puntero;\r
+ END;\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE PILAC_Inicializar( VAR l: PILAC_Pila );\r
+FUNCTION PILAC_vacio( l: PILAC_Pila): BOOLEAN;\r
+FUNCTION PILAC_lleno( l: PILAC_Pila): BOOLEAN;\r
+\r
+PROCEDURE PILAC_poner( VAR l: PILAC_Pila; e: Tipo_Elem );\r
+PROCEDURE PILAC_sacar( VAR l: PILAC_Pila; VAR e: Tipo_Elem);\r
+PROCEDURE PILAC_vaciar( VAR l: PILAC_Pila );\r
+PROCEDURE PILAC_copiar( a: PILAC_Pila; VAR b: PILAC_Pila );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure PILAC_Almac_Inicializar( VAR almac : PILAC_Almac );\r
+var i : PILAC_Puntero;\r
+begin\r
+ almac.primero_dispo := 1;\r
+ for i := 1 to PILAC_MAX_CURSOR - 1 do\r
+ begin\r
+ almac.disponibles[i] := i + 1;\r
+ end;\r
+ almac.disponibles[PILAC_MAX_CURSOR] := PILAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function PILAC_Almac_HayLugar( almac : PILAC_Almac ): boolean;\r
+begin\r
+ PILAC_Almac_HayLugar := almac.primero_dispo <> PILAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure PILAC_Almac_Reservar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
+begin\r
+ if not PILAC_Almac_HayLugar( almac )\r
+ then\r
+ puntero := PILAC_Nulo\r
+ else begin\r
+ puntero := almac.primero_dispo;\r
+ almac.primero_dispo := almac.disponibles[ puntero ];\r
+ end;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure PILAC_Almac_Liberar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
+begin\r
+ almac.disponibles[ puntero ] := almac.primero_dispo;\r
+ almac.primero_dispo := puntero;\r
+ puntero := PILAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure PILAC_Almac_Acceder( almac : PILAC_Almac; puntero : PILAC_Puntero; VAR elemento : PILAC_Nodo );\r
+begin\r
+ elemento := almac.almacenamiento[ puntero ];\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure PILAC_Almac_Modificar( VAR almac : PILAC_Almac; puntero : PILAC_Puntero; elemento : PILAC_Nodo );\r
+begin\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE PILAC_Inicializar( VAR l: PILAC_Pila );\r
+BEGIN\r
+ PILAC_Almac_Inicializar( l.almac );\r
+ l.primero := PILAC_Nulo;\r
+END;\r
+\r
+FUNCTION PILAC_vacio( l: PILAC_Pila): BOOLEAN;\r
+BEGIN\r
+ PILAC_vacio := ( l.Primero = PILAC_Nulo);\r
+END;\r
+\r
+FUNCTION PILAC_lleno( l: PILAC_Pila): BOOLEAN;\r
+BEGIN\r
+ PILAC_lleno := not PILAC_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE PILAC_poner( VAR l: PILAC_Pila; e: Tipo_Elem);\r
+VAR\r
+ n : PILAC_Nodo;\r
+ np: PILAC_Puntero;\r
+BEGIN\r
+ n.Elem := e;\r
+ n.sig := l.primero;\r
+ PILAC_Almac_Reservar( l.almac, np );\r
+ PILAC_Almac_Modificar( l.almac, np, n );\r
+ l.primero := np;\r
+END;\r
+\r
+{ pre: no esta vacia }\r
+PROCEDURE PILAC_sacar( VAR l: PILAC_Pila; VAR e: Tipo_Elem);\r
+VAR n : PILAC_Nodo;\r
+ tmp : PILAC_Nodo;\r
+ tmpp: PILAC_Puntero;\r
+BEGIN\r
+ PILAC_Almac_Acceder( l.almac, l.primero, n );\r
+ PILAC_Almac_Liberar( l.almac, l.primero );\r
+ l.primero := n.Sig;\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+END;\r
+\r
+PROCEDURE PILAC_vaciar( VAR l: PILAC_Pila );\r
+VAR np : PILAC_Puntero;\r
+ n : PILAC_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> PILAC_Nulo ) do begin\r
+ PILAC_Almac_Acceder( l.almac, np, n );\r
+ PILAC_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := PILAC_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE PILAC_copiar( a : PILAC_Pila; VAR b : PILAC_Pila );\r
+VAR np, mp, tmpp : PILAC_Puntero;\r
+ n, m : PILAC_Nodo;\r
+\r
+BEGIN\r
+ if a.primero = PILAC_Nulo then exit;\r
+ np := a.primero;\r
+ PILAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ PILAC_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> PILAC_Nulo ) do begin\r
+\r
+ PILAC_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ PILAC_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ PILAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := PILAC_Nulo;\r
+ PILAC_Almac_Modificar( b.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+unit cola_C;\r
+\r
+{\r
+ IMPLEMENTACION : colas\r
+ ALMACENAMIENTO : CURSORES\r
+ \r
+}\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const COLA_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+TYPE\r
+ COLAC_puntero = integer;\r
+\r
+const\r
+ COLAC_nulo : COLAC_puntero = 0;\r
+\r
+type\r
+\r
+ COLAC_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : COLAC_puntero;\r
+ END;\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ COLAC_Almac = record\r
+ almacenamiento : array [ 1 .. COLAC_MAX_CURSOR ] of COLAC_Nodo;\r
+ siguientes : array [ 1 .. COLAC_MAX_CURSOR ] of COLAC_Puntero;\r
+ primero_dispo : TTDA_Puntero;\r
+ end;\r
+\r
+ \r
+ COLAC_Cola = RECORD\r
+ almac : COLAC_Almac;\r
+ primero: COLAC_puntero;\r
+ ultimo : COLAC_puntero;\r
+ END;\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE COLAC_Inicializar( VAR l: COLAC_Cola );\r
+FUNCTION COLAC_vacio( l: COLAC_Cola): BOOLEAN;\r
+FUNCTION COLAC_lleno( l: COLAC_Cola): BOOLEAN;\r
+\r
+PROCEDURE COLAC_poner( VAR l: COLAC_Cola; e: Tipo_Elem );\r
+PROCEDURE COLAC_sacar( VAR l: COLAC_Cola; VAR e: Tipo_Elem);\r
+PROCEDURE COLAC_vaciar( VAR l: COLAC_Cola );\r
+PROCEDURE COLAC_copiar( l: COLAC_Cola; VAR b: COLAC_Cola );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure COLAC_Almac_Inicializar( VAR almac : COLAC_Almac );\r
+var i : COLAC_Puntero;\r
+begin\r
+ almac.primero_dispo := 1;\r
+ for i := 1 to COLAC_CURSOR_MAX - 1 do\r
+ begin\r
+ siguientes[i] := i + 1;\r
+ end;\r
+ siguientes[COLAC_CURSOR_MAX] := COLAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function COLAC_Almac_HayLugar( almac : COLAC_Almac ): boolean;\r
+begin\r
+ COLAC_Almac_HayLugar := almac.primero_dispo = COLAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure COLAC_Almac_Reservar( VAR almac : COLAC_Almac; VAR puntero : COLAC_Puntero );\r
+begin\r
+ if not COLAC_Almac_HayLugar( almac )\r
+ then\r
+ puntero := COLAC_Nulo\r
+ else begin\r
+ puntero := almac.primero_dispo;\r
+ almac.primero_dispo := almac.siguientes[ puntero ];\r
+ end;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure COLAC_Almac_Liberar( VAR almac : COLAC_Almac; VAR puntero : COLAC_Puntero );\r
+begin\r
+ almac.siguientes[ puntero ] := almac.primero_dispo;\r
+ almac.primero_dispo := puntero;\r
+ puntero := COLAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure COLAC_Almac_Acceder( almac : TTDA_Almac; puntero : COLAC_Puntero; VAR elemento : COLAC_Nodo );\r
+begin\r
+ elemento := almac.almacenamiento[ puntero ];\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure COLAC_Almac_Modificar( VAR almac : COLAC_Almac; puntero : COLAC_Puntero; elemento : COLAC_Nodo );\r
+begin\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE COLAC_Inicializar( VAR l: COLAC_Cola );\r
+BEGIN\r
+ COLAC_Almac_Inicializar( l.almac );\r
+ primero := COLAC_Nulo;\r
+ ultimo := COLAC_Nulo;\r
+END;\r
+\r
+FUNCTION COLAC_vacio( l: COLAC_Cola): BOOLEAN;\r
+BEGIN\r
+ COLAC_vacio := ( l.Primero = COLAC_Nulo);\r
+END;\r
+\r
+FUNCTION COLAC_lleno( l: COLAC_Cola): BOOLEAN;\r
+BEGIN\r
+ COLAC_lleno := not COLAC_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE COLAC_poner( VAR l: COLAC_Cola; e: Tipo_Elem);\r
+VAR\r
+ p : COLAC_puntero;\r
+ n : COLAC_Nodo;\r
+ np: COLAC_Puntero;\r
+ m : COLAC_Nodo;\r
+BEGIN\r
+ COLAC_Almac_Reservar( l.almac, np );\r
+ n.Elem := e;\r
+ n.sig := COLAC_Nulo;\r
+ COLAC_Almac_Modificar( l.almac, np, n );\r
+ \r
+ if l.ultimo <> COLAC_Nulo then begin\r
+ { la cola no esta vacia, entonces tengo que modificar el ultimo }\r
+\r
+ { accedo al almacenamiento por el ultimo }\r
+ COLAC_Almac_Acceder( l, l.ultimo, m );\r
+ m.sig := np;\r
+ COLAC_Almac_Modificar( l.almac, l.ultimo, m );\r
+ end;\r
+ else\r
+ { si el ultimo es nulo significa que la cola esta vacia }\r
+ { pongo el primero al ultimo tambien }\r
+ l.primero := np;\r
+ l.ultimo := np;\r
+END;\r
+\r
+{ pre: no esta vacia }\r
+PROCEDURE COLAC_sacar( l: COLAC_Cola; VAR e: Tipo_Elem);\r
+VAR n : COLAC_Nodo;\r
+ tmp : COLAC_Nodo;\r
+ tmpp: COLAC_Puntero;\r
+BEGIN\r
+ COLAC_Almac_Acceder( l.almac, l.primero, n );\r
+ COLAC_Almac_Liberar( l.almac, l.primero );\r
+ l.primero := n.Sig;\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+\r
+ if n.sig = COLAC_Nulo then\r
+ { la cola quedo vacia }\r
+ { el ultimo pasa a nulo, y el primero ya es nulo porque el siguiente de n era nulo }\r
+ l.ultimo := COLAC_Nulo;\r
+END;\r
+\r
+PROCEDURE COLAC_vaciar( VAR a: COLAC_Cola );\r
+VAR np : COLAC_Puntero;\r
+ n : COLAC_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> COLAC_Nulo ) do begin\r
+ COLAC_Almac_Acceder( l.almac, np, n );\r
+ COLAC_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := COLAC_Nulo;\r
+ l.ultimo := COLAC_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE COLAC_copiar( a : COLAC_Cola; VAR b : COLAC_Cola );\r
+VAR np : COLAC_Puntero;\r
+ n : COLAC_Nodo;\r
+BEGIN\r
+ if a.primero = COLAC_Nulo then return;\r
+ np := a.primero;\r
+ COLAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ COLAC_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> COLAC_Nulo ) do begin\r
+\r
+ COLAC_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ COLAC_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ COLAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := COLAC_Nulo;\r
+ b.ultimo := mp;\r
+ COLAC_Almac_Modificar( b.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+program eje_lista;\r
+\r
+{\r
+ IMPLEMENTACION : EJERCICIOS DE ARBOLES\r
+ \r
+}\r
+uses tda_gral, t_lSC;\r
+\r
+\r
+{ =========================================================================== }\r
+{ =========================================================================== }\r
+{ =========================================================================== }\r
+{\r
+ Este procedimiento elimina los duplicados de una lista\r
+}\r
+PROCEDURE eliminar_dupes( VAR l: LSC_lista);\r
+ \r
+ {\r
+ buscar a partir del corriente el proximo con un clave determinada\r
+ }\r
+ FUNCTION buscar( VAR l: LSC_lista; c: Tipo_Clave ): boolean;\r
+ VAR\r
+ enc, error: boolean;\r
+ e: Tipo_Elem;\r
+ BEGIN\r
+ { paso al siguiente de entrada }\r
+ LSC_mover_cte( l, LSC_siguiente, error );\r
+\r
+ enc := false;\r
+ WHILE(not error) and( not enc ) DO BEGIN\r
+ LSC_elem_cte( l, e );\r
+\r
+ IF Devolver_Clave_Elem( e ) = c\r
+ THEN { lo encontre }\r
+ enc := true\r
+ ELSE\r
+ { voy al siguiente }\r
+ LSC_mover_cte( l, LSC_siguiente, error );\r
+ END;\r
+\r
+ END;\r
+\r
+VAR\r
+ error: boolean;\r
+ e: Tipo_Elem;\r
+BEGIN\r
+ { si esta vacia no tengo nada que hacer }\r
+ if LSC_Vacio( l ) THEN EXIT;\r
+\r
+ LSC_mover_cte( l, LSC_primero, error );\r
+\r
+ WHILE not error DO BEGIN\r
+\r
+ { obtengo el elemento que voy a usar como pivote, para borrar sus duplicados }\r
+ LSC_elem_cte( l, e );\r
+\r
+ { itero borrando dupes }\r
+ WHILE buscar( l, Devolver_Clave_Elem( e ) ) DO\r
+ LSC_borrar_cte( l );\r
+\r
+ { vuelvo al primero para buscar el original }\r
+ LSC_mover_cte( l, LSC_primero, error );\r
+ error := buscar( l, Devolver_Clave_Elem( e ));\r
+ { paso al siguiente }\r
+ LSC_mover_cte( l, LSC_siguiente, error );\r
+\r
+ end;\r
+END;\r
+\r
+{\r
+ Insertar ordenado en una lista doblemente enlazada\r
+}\r
+PROCEDURE insertar_ordenado( VAR l: LDC_lista, e: Tipo_elem );\r
+ \r
+ {\r
+ buscar a partir del corriente el proximo con un clave determinada\r
+ }\r
+ FUNCTION buscar( VAR l: LDC_lista; c: Tipo_Clave ): boolean;\r
+ VAR\r
+ enc, error: boolean;\r
+ e: Tipo_Elem;\r
+ BEGIN\r
+ { paso al siguiente de entrada }\r
+ LDC_mover_cte( l, LDC_siguiente, error );\r
+\r
+ enc := false;\r
+ WHILE(not error) and( not enc ) DO BEGIN\r
+ LDC_elem_cte( l, e );\r
+\r
+ IF Devolver_Clave_Elem( e ) = c\r
+ THEN { lo encontre }\r
+ enc := true\r
+ ELSE\r
+ { voy al siguiente }\r
+ LDC_mover_cte( l, LDC_siguiente, error );\r
+ END;\r
+\r
+ END;\r
+\r
+VAR\r
+ error: boolean;\r
+ n: Tipo_Elem;\r
+BEGIN\r
+ { si esta vacia no tengo nada que hacer }\r
+ if LDC_Vacio( l )\r
+ THEN BEGIN\r
+ LDC_insertar( l, primero, error );\r
+ exit;\r
+ END;\r
+\r
+ LDC_mover_cte( l, LDC_primero, error );\r
+\r
+ { busco donde corresponde insertar el elem }\r
+ error := buscar( l, Devolver_Clave_Elem( e ));\r
+\r
+ { obtengo el elemento pivote }\r
+ LDC_elem_cte( l, n );\r
+\r
+ if error\r
+ THEN BEGIN\r
+ { aca se deberia manejar la insercion de duplicados }\r
+ LDC_insertar( l, LDC_siguiente, error );\r
+ END\r
+ ELSE BEGIN\r
+ IF Devolver_Clave_Elem( e ) > Devolver_Clave_Elem( n )\r
+ THEN\r
+ LDC_insertar( l, LDC_siguiente, error )\r
+ ELSE\r
+ LDC_insertar( l, LDC_anterior, error );\r
+\r
+END;\r
+\r
+\r
+{ procedimiento principal }\r
+VAR\r
+ a: integer;\r
+BEGIN\r
+\r
+END.\r
--- /dev/null
+unit lista_simple_C;\r
+\r
+{\r
+ IMPLEMENTACION : LISTAS SIMPLES\r
+ ALMACENAMIENTO : CURSORES\r
+ \r
+}\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const LSC_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+TYPE\r
+ LSC_puntero = integer;\r
+\r
+const\r
+ LSC_nulo : LSC_puntero = 0;\r
+\r
+type\r
+\r
+ LSC_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : LSC_puntero;\r
+ END;\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ LSC_Almac = record\r
+ almacenamiento : array [ 1 .. LSC_MAX_CURSOR ] of LSC_Nodo;\r
+ siguientes : array [ 1 .. LSC_MAX_CURSOR ] of LSC_Puntero;\r
+ primero_dispo : TTDA_Puntero;\r
+ end;\r
+\r
+ \r
+ LSC_Lista_Simple_C = RECORD\r
+ almac : LSC_Almac;\r
+ primero: LSC_puntero;\r
+ corriente : LSC_puntero;\r
+ END;\r
+\r
+ LSC_movimiento = ( LSC_primero, LSC_siguiente );\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE LSC_Inicializar( VAR l: LSC_Lista_Simple_C );\r
+FUNCTION LSC_vacio( l: LSC_Lista_Simple_C): BOOLEAN;\r
+FUNCTION LSC_lleno( l: LSC_Lista_Simple_C): BOOLEAN;\r
+\r
+PROCEDURE LSC_elem_cte( l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+PROCEDURE LSC_modif_cte( VAR l: LSC_Lista_Simple_C; e: Tipo_Elem);\r
+PROCEDURE LSC_mover_cte( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; VAR error: BOOLEAN );\r
+PROCEDURE LSC_borrar_cte( VAR l: LSC_Lista_Simple_C );\r
+PROCEDURE LSC_insertar( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; e: Tipo_Elem );\r
+PROCEDURE LSC_vaciar( VAR l: LSC_Lista_Simple_C );\r
+PROCEDURE LSC_copiar( l: LSC_Lista_Simple_C; VAR b: LSC_Lista_Simple_C );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure LSC_Almac_Inicializar( VAR almac : LSC_Almac );\r
+var i : LSC_Puntero;\r
+begin\r
+ almac.primero_dispo := 1;\r
+ for i := 1 to LSC_CURSOR_MAX - 1 do\r
+ begin\r
+ siguientes[i] := i + 1;\r
+ end;\r
+ siguientes[LSC_CURSOR_MAX] := LSC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function LSC_Almac_HayLugar( almac : LSC_Almac ): boolean;\r
+begin\r
+ LSC_Almac_HayLugar := almac.primero_dispo = LSC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure LSC_Almac_Reservar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+begin\r
+ if not LSC_Almac_HayLugar( almac )\r
+ then\r
+ puntero := LSC_Nulo\r
+ else begin\r
+ puntero := almac.primero_dispo;\r
+ almac.primero_dispo := almac.siguientes[ puntero ];\r
+ end;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure LSC_Almac_Liberar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+begin\r
+ almac.siguientes[ puntero ] := almac.primero_dispo;\r
+ almac.primero_dispo := puntero;\r
+ puntero := LSC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure LSC_Almac_Acceder( almac : TTDA_Almac; puntero : LSC_Puntero; VAR elemento : LSC_Nodo );\r
+begin\r
+ elemento := almac.almacenamiento[ puntero ];\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure LSC_Almac_Modificar( VAR almac : LSC_Almac; puntero : LSC_Puntero; elemento : LSC_Nodo );\r
+begin\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE LSC_Inicializar( VAR l: LSC_Lista_Simple_C );\r
+BEGIN\r
+ LSC_Almac_Inicializar( l.almac );\r
+ primero := LSC_Nulo;\r
+ corriente := LSC_Nulo;\r
+END;\r
+\r
+FUNCTION LSC_vacio( l: LSC_Lista_Simple_C): BOOLEAN;\r
+BEGIN\r
+ LSC_vacio := ( l.Primero = LSC_Nulo);\r
+END;\r
+\r
+FUNCTION LSC_lleno( l: LSC_Lista_Simple_C): BOOLEAN;\r
+BEGIN\r
+ LSC_lleno := not LSC_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE LSC_elem_cte( l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+var n : LSC_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l, l.Corriente, n );\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+END;\r
+\r
+PROCEDURE LSC_modif_cte( VAR l: LSC_Lista_Simple_C; e: Tipo_Elem);\r
+var n : LSC_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l, l.Corriente, n );\r
+\r
+ { y la asigno al parametro }\r
+ n.Elem := e;\r
+\r
+ { y modifico el almacenamiento }\r
+ LSC_Almac_Modificar( l, l.Corriente, n );\r
+\r
+END;\r
+\r
+PROCEDURE LSC_mover_cte( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; VAR error: BOOLEAN );\r
+VAR n : LSC_Nodo;\r
+BEGIN\r
+ error := FALSE;\r
+ CASE m OF\r
+ LSC_primero:\r
+ l.Corriente := l.Primero;\r
+ LSC_siguiente:\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l, l.Corriente, n );\r
+ \r
+ IF n.siguiente = LSC_Nulo\r
+ THEN\r
+ error := TRUE\r
+ ELSE\r
+ l.corriente := n.siguiente;\r
+ END;\r
+END;\r
+\r
+PROCEDURE LSC_borrar_cte( VAR l: LSC_Lista_Simple_C );\r
+VAR n : LSC_Nodo;\r
+ tmp : LSC_Nodo;\r
+ tmpp: LSC_Puntero;\r
+BEGIN\r
+ if l.corriente = l.primero then begin\r
+ LSC_Almac_Acceder( l.almac, l.primero, n );\r
+ l.primero := n.Sig;\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := l.primero;\r
+ end;\r
+ else begin\r
+ tmpp := l.primero;\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+ while( tmp.sig <> l.corriente ) do begin\r
+ tmpp := tmp.sig;\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+ end;\r
+ LSC_Almac_Acceder( l.almac, l.corriente, n );\r
+ tmp.sig := n.Sig;\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := tmpp;\r
+ end;\r
+END;\r
+\r
+PROCEDURE LSC_insertar( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; e: Tipo_Elem );\r
+VAR\r
+ p : LSC_puntero;\r
+ n : LSC_Nodo;\r
+ np: LSC_Puntero;\r
+BEGIN\r
+ LSC_Almac_Reservar( l.almac, np );\r
+ n.Elem := e;\r
+ CASE m OF\r
+ LSC_primero:\r
+ n.sig := l.primero;\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+ l.primero := np;\r
+ LSC_siguiente:\r
+ LSC_Almac_Acceder( l.almac, l.corriente, ant );\r
+ n.sig := ant.sig;\r
+ ant.sig := np;\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+ LSC_Almac_Modificar( l.almac, l.corriente, ant );\r
+ END;\r
+\r
+ l.Corriente := np;\r
+\r
+END;\r
+\r
+PROCEDURE LSC_vaciar( VAR a: LSC_Lista_Simple_C );\r
+VAR np : LSC_Puntero;\r
+ n : LSC_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> LSC_Nulo ) do begin\r
+ LSC_Almac_Acceder( l.almac, np, n );\r
+ LSC_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := LSC_Nulo;\r
+ l.corriente := LSC_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE LSC_copiar( a : LSC_Lista_Simple_C; VAR b : LSC_Lista_Simple_C );\r
+VAR np : LSC_Puntero;\r
+ n : LSC_Nodo;\r
+BEGIN\r
+ if a.primero = LSC_Nulo then return;\r
+ np := a.primero;\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+ LSC_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ b.corriente := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> LSC_Nulo ) do begin\r
+\r
+ LSC_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ LSC_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := LSC_Nulo;\r
+ LSC_Almac_Modificar( l.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+unit lista_simple_P;\r
+\r
+{\r
+ IMPLEMENTACION : LISTAS SIMPLES\r
+ ALMACENAMIENTO : PUNTERO\r
+ \r
+}\r
+\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const LSC_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el almacenamiento }\r
+TYPE\r
+ LSC_puntero = ^LSC_Nodo;\r
+\r
+const\r
+ LSC_nulo : LSC_puntero = nil;\r
+\r
+type\r
+\r
+ LSC_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : LSC_puntero;\r
+ END;\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ LSC_Almac = record\r
+ end;\r
+\r
+ \r
+ LSC_Lista_Simple_C = RECORD\r
+ almac : LSC_Almac;\r
+ primero: LSC_puntero;\r
+ corriente : LSC_puntero;\r
+ END;\r
+\r
+ LSC_movimiento = ( LSC_primero, LSC_siguiente );\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE LSC_Inicializar( VAR l: LSC_Lista_Simple_C );\r
+FUNCTION LSC_vacio( l: LSC_Lista_Simple_C): BOOLEAN;\r
+FUNCTION LSC_lleno( l: LSC_Lista_Simple_C): BOOLEAN;\r
+\r
+PROCEDURE LSC_elem_cte( l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+PROCEDURE LSC_modif_cte( VAR l: LSC_Lista_Simple_C; e: Tipo_Elem);\r
+PROCEDURE LSC_mover_cte( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; VAR error: BOOLEAN );\r
+PROCEDURE LSC_borrar_cte( VAR l: LSC_Lista_Simple_C );\r
+PROCEDURE LSC_insertar( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; e: Tipo_Elem );\r
+PROCEDURE LSC_vaciar( VAR l: LSC_Lista_Simple_C );\r
+PROCEDURE LSC_copiar( l: LSC_Lista_Simple_C; VAR b: LSC_Lista_Simple_C );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure LSC_Almac_Inicializar( VAR almac : LSC_Almac );\r
+begin\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function LSC_Almac_HayLugar( almac : LSC_Almac ): boolean;\r
+begin\r
+ LSC_Almac_HayLugar := true;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure LSC_Almac_Reservar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+begin\r
+ puntero := new( LSC_Nodo );\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure LSC_Almac_Liberar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+begin\r
+ dispose( puntero );\r
+ puntero := LSC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure LSC_Almac_Acceder( almac : TTDA_Almac; puntero : LSC_Puntero; VAR elemento : LSC_Nodo );\r
+begin\r
+ elemento := puntero^;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure LSC_Almac_Modificar( VAR almac : LSC_Almac; puntero : LSC_Puntero; elemento : LSC_Nodo );\r
+begin\r
+ puntero^ := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE LSC_Inicializar( VAR l: LSC_Lista_Simple_C );\r
+BEGIN\r
+ LSC_Almac_Inicializar( l.almac );\r
+ primero := LSC_Nulo;\r
+ corriente := LSC_Nulo;\r
+END;\r
+\r
+FUNCTION LSC_vacio( l: LSC_Lista_Simple_C): BOOLEAN;\r
+BEGIN\r
+ LSC_vacio := ( l.Primero = LSC_Nulo);\r
+END;\r
+\r
+FUNCTION LSC_lleno( l: LSC_Lista_Simple_C): BOOLEAN;\r
+BEGIN\r
+ LSC_lleno := not LSC_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE LSC_elem_cte( l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+var n : LSC_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l, l.Corriente, n );\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+END;\r
+\r
+PROCEDURE LSC_modif_cte( VAR l: LSC_Lista_Simple_C; e: Tipo_Elem);\r
+var n : LSC_Nodo;\r
+BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l, l.Corriente, n );\r
+\r
+ { y la asigno al parametro }\r
+ n.Elem := e;\r
+\r
+ { y modifico el almacenamiento }\r
+ LSC_Almac_Modificar( l, l.Corriente, n );\r
+\r
+END;\r
+\r
+PROCEDURE LSC_mover_cte( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; VAR error: BOOLEAN );\r
+VAR n : LSC_Nodo;\r
+BEGIN\r
+ error := FALSE;\r
+ CASE m OF\r
+ LSC_primero:\r
+ l.Corriente := l.Primero;\r
+ LSC_siguiente:\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder( l, l.Corriente, n );\r
+ \r
+ IF n.siguiente = LSC_Nulo\r
+ THEN\r
+ error := TRUE\r
+ ELSE\r
+ l.corriente := n.siguiente;\r
+ END;\r
+END;\r
+\r
+PROCEDURE LSC_borrar_cte( VAR l: LSC_Lista_Simple_C );\r
+VAR n : LSC_Nodo;\r
+ tmp : LSC_Nodo;\r
+ tmpp: LSC_Puntero;\r
+BEGIN\r
+ if l.corriente = l.primero then begin\r
+ LSC_Almac_Acceder( l.almac, l.primero, n );\r
+ l.primero := n.Sig;\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := l.primero;\r
+ end;\r
+ else begin\r
+ tmpp := l.primero;\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+ while( tmp.sig <> l.corriente ) do begin\r
+ tmpp := tmp.sig;\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+ end;\r
+ LSC_Almac_Acceder( l.almac, l.corriente, n );\r
+ tmp.sig := n.Sig;\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+ l.corriente := tmpp;\r
+ end;\r
+END;\r
+\r
+PROCEDURE LSC_insertar( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; e: Tipo_Elem );\r
+VAR\r
+ p : LSC_puntero;\r
+ n : LSC_Nodo;\r
+ np: LSC_Puntero;\r
+BEGIN\r
+ LSC_Almac_Reservar( l.almac, np );\r
+ n.Elem := e;\r
+ CASE m OF\r
+ LSC_primero:\r
+ n.sig := l.primero;\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+ l.primero := np;\r
+ LSC_siguiente:\r
+ LSC_Almac_Acceder( l.almac, l.corriente, ant );\r
+ n.sig := ant.sig;\r
+ ant.sig := np;\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+ LSC_Almac_Modificar( l.almac, l.corriente, ant );\r
+ END;\r
+\r
+ l.Corriente := np;\r
+\r
+END;\r
+\r
+PROCEDURE LSC_vaciar( VAR a: LSC_Lista_Simple_C );\r
+VAR np : LSC_Puntero;\r
+ n : LSC_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> LSC_Nulo ) do begin\r
+ LSC_Almac_Acceder( l.almac, np, n );\r
+ LSC_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := LSC_Nulo;\r
+ l.corriente := LSC_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE LSC_copiar( a : LSC_Lista_Simple_C; VAR b : LSC_Lista_Simple_C );\r
+VAR np : LSC_Puntero;\r
+ n : LSC_Nodo;\r
+BEGIN\r
+ if a.primero = LSC_Nulo then return;\r
+ np := a.primero;\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+ LSC_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ b.corriente := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> LSC_Nulo ) do begin\r
+\r
+ LSC_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ LSC_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := LSC_Nulo;\r
+ LSC_Almac_Modificar( l.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+unit pila_C;\r
+\r
+{\r
+ IMPLEMENTACION : pilas\r
+ ALMACENAMIENTO : CURSORES\r
+ \r
+}\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+interface\r
+\r
+{ usa las funciones generales de TDAs }\r
+uses tda_gral;\r
+\r
+{ maximo tamano del cursor }\r
+const COLA_MAX_CURSOR = 100;\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+TYPE\r
+ PILAC_puntero = integer;\r
+\r
+const\r
+ PILAC_nulo : PILAC_puntero = 0;\r
+\r
+type\r
+\r
+ PILAC_nodo = RECORD\r
+ Elem : Tipo_Elem;\r
+ Sig : PILAC_puntero;\r
+ END;\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+ PILAC_Almac = record\r
+ almacenamiento : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Nodo;\r
+ siguientes : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Puntero;\r
+ primero_dispo : TTDA_Puntero;\r
+ end;\r
+\r
+ \r
+ PILAC_Pila = RECORD\r
+ almac : PILAC_Almac;\r
+ primero: PILAC_puntero;\r
+ END;\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+\r
+PROCEDURE PILAC_Inicializar( VAR l: PILAC_Pila );\r
+FUNCTION PILAC_vacio( l: PILAC_Pila): BOOLEAN;\r
+FUNCTION PILAC_lleno( l: PILAC_Pila): BOOLEAN;\r
+\r
+PROCEDURE PILAC_poner( VAR l: PILAC_Pila; e: Tipo_Elem );\r
+PROCEDURE PILAC_sacar( VAR l: PILAC_Pila; VAR e: Tipo_Elem);\r
+PROCEDURE PILAC_vaciar( VAR l: PILAC_Pila );\r
+PROCEDURE PILAC_copiar( l: PILAC_Pila; VAR b: PILAC_Pila );\r
+\r
+implementation\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure PILAC_Almac_Inicializar( VAR almac : PILAC_Almac );\r
+var i : PILAC_Puntero;\r
+begin\r
+ almac.primero_dispo := 1;\r
+ for i := 1 to PILAC_CURSOR_MAX - 1 do\r
+ begin\r
+ siguientes[i] := i + 1;\r
+ end;\r
+ siguientes[PILAC_CURSOR_MAX] := PILAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function PILAC_Almac_HayLugar( almac : PILAC_Almac ): boolean;\r
+begin\r
+ PILAC_Almac_HayLugar := almac.primero_dispo = PILAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure PILAC_Almac_Reservar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
+begin\r
+ if not PILAC_Almac_HayLugar( almac )\r
+ then\r
+ puntero := PILAC_Nulo\r
+ else begin\r
+ puntero := almac.primero_dispo;\r
+ almac.primero_dispo := almac.siguientes[ puntero ];\r
+ end;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure PILAC_Almac_Liberar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
+begin\r
+ almac.siguientes[ puntero ] := almac.primero_dispo;\r
+ almac.primero_dispo := puntero;\r
+ puntero := PILAC_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure PILAC_Almac_Acceder( almac : TTDA_Almac; puntero : PILAC_Puntero; VAR elemento : PILAC_Nodo );\r
+begin\r
+ elemento := almac.almacenamiento[ puntero ];\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure PILAC_Almac_Modificar( VAR almac : PILAC_Almac; puntero : PILAC_Puntero; elemento : PILAC_Nodo );\r
+begin\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+end;\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+PROCEDURE PILAC_Inicializar( VAR l: PILAC_Pila );\r
+BEGIN\r
+ PILAC_Almac_Inicializar( l.almac );\r
+ primero := PILAC_Nulo;\r
+END;\r
+\r
+FUNCTION PILAC_vacio( l: PILAC_Pila): BOOLEAN;\r
+BEGIN\r
+ PILAC_vacio := ( l.Primero = PILAC_Nulo);\r
+END;\r
+\r
+FUNCTION PILAC_lleno( l: PILAC_Pila): BOOLEAN;\r
+BEGIN\r
+ PILAC_lleno := not PILAC_Almac_HayLugar( l.almac );\r
+END;\r
+\r
+PROCEDURE PILAC_poner( VAR l: PILAC_Pila; e: Tipo_Elem);\r
+VAR\r
+ n : PILAC_Nodo;\r
+ np: PILAC_Puntero;\r
+BEGIN\r
+ n.Elem := e;\r
+ n.sig := l.primero;\r
+ PILAC_Almac_Reservar( l.almac, np );\r
+ PILAC_Almac_Modificar( l.almac, np, n );\r
+ l.primero := np;\r
+END;\r
+\r
+{ pre: no esta vacia }\r
+PROCEDURE PILAC_sacar( l: PILAC_Pila; VAR e: Tipo_Elem);\r
+VAR n : PILAC_Nodo;\r
+ tmp : PILAC_Nodo;\r
+ tmpp: PILAC_Puntero;\r
+BEGIN\r
+ PILAC_Almac_Acceder( l.almac, l.primero, n );\r
+ PILAC_Almac_Liberar( l.almac, l.primero );\r
+ l.primero := n.Sig;\r
+\r
+ { y se lo asigno al parametro }\r
+ e := n.Elem;\r
+END;\r
+\r
+PROCEDURE PILAC_vaciar( VAR a: PILAC_Pila );\r
+VAR np : PILAC_Puntero;\r
+ n : PILAC_Nodo;\r
+BEGIN\r
+ np := l.primero;\r
+ while( np <> PILAC_Nulo ) do begin\r
+ PILAC_Almac_Acceder( l.almac, np, n );\r
+ PILAC_Almac_Liberar( l.almac, np );\r
+ np := n.sig;\r
+ end;\r
+ l.primero := PILAC_Nulo;\r
+END;\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+PROCEDURE PILAC_copiar( a : PILAC_Pila; VAR b : PILAC_Pila );\r
+VAR np : PILAC_Puntero;\r
+ n : PILAC_Nodo;\r
+BEGIN\r
+ if a.primero = PILAC_Nulo then return;\r
+ np := a.primero;\r
+ PILAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ PILAC_Almac_Reservar( b.almac, mp );\r
+ b.primero := mp;\r
+ m.elem := n.elem;\r
+\r
+ while( n.sig <> PILAC_Nulo ) do begin\r
+\r
+ PILAC_Almac_Reservar( b.almac, tmpp );\r
+ m.sig := tmpp;\r
+ PILAC_Almac_Modificar( b.almac, mp, m );\r
+\r
+ np := n.sig;\r
+ PILAC_Almac_Acceder( a.almac, np, n );\r
+\r
+ mp := tmpp;\r
+ m.elem := n.elem;\r
+\r
+ end;\r
+ m.sig := PILAC_Nulo;\r
+ PILAC_Almac_Modificar( b.almac, mp, m );\r
+END;\r
+\r
+end.\r
--- /dev/null
+unit tda_almac;\r
+{\r
+ unidad basica de almacenamiento de elementos en los tipos de dato abstractos\r
+\r
+ en esta unidad pretendemos definir como se almacenan los elementos en las listas, pilas, etc...\r
+ vamos a definir una base sobre la cual ellas van a pedir y liberar elemntos.\r
+ esta base no es necesariamente general para todos los TDAs que se definan,\r
+ simplemente demuestra como se puede hacer una interface unica, y que luego se implemente de\r
+ distintas maneras, por ejemplo cursores, punteros, etc, sin cambiar la implementacion del tipo.\r
+}\r
+\r
+{\r
+ ACLARACION RESPECTO A LA INTERFASE\r
+ ++++++++++++++++++++++++++++++++++\r
+\r
+ por razones que no vienen al caso explicar en este comentario, se deben definir e implementar estas\r
+ primitivas para cada tipo que se vaya a usar, obviamente con nombres distintos.\r
+ Asi que vamos a definir como notacion poner un prefijo que indique el tipo que se esta refiriendo\r
+\r
+\r
+ ACLARACION 2\r
+ ============\r
+\r
+ este codigo no compila, porque su intencion es mostrar ambas interfases juntas, para cada implementacion\r
+ se debe codificar la que corresponda\r
+\r
+}\r
+\r
+interface\r
+\r
+uses tda_gral;\r
+\r
+{\r
+ esta es la interfase comun para el almacenamiento de elementos\r
+ usando esta interfase se pueden hacer todas lo necesario con los datos\r
+ y se puede implementar de la forma mas conveniente.\r
+ Vamos a implementar esta interfase con cursores y punteros,\r
+ ambas al mismo tiempo, asi se pueden ver las diferencias entre una y otra\r
+}\r
+const\r
+{ ================================================================= }\r
+{ para cursores debo definir primero cuanto es el tamano del cursor }\r
+TTDA_MAX_CURSOR = 100;\r
+\r
+\r
+type\r
+{ =================================== }\r
+{ defino el puntero de almacenamiento }\r
+\r
+{ CURSORES }\r
+TTDA_Puntero = int;\r
+\r
+{ PUNTEROS }\r
+TTDA_Puntero = ^TTDA_Nodo;\r
+\r
+\r
+const\r
+{ ======================================= }\r
+{ debemos definir un tipo de puntero nulo }\r
+\r
+{ CURSORES }\r
+TTDA_Nulo : TTDA_Puntero = 0;\r
+\r
+{ PUNTEROS }\r
+TTDA_Nulo : TTDA_Puntero = nil;\r
+\r
+\r
+type\r
+{ ====================================== }\r
+{ defino la estructura de almacenamiento }\r
+\r
+{ CURSORES }\r
+TTDA_Almac = record\r
+ almacenamiento : array [ 1 .. TTDA_MAX_CURSOR ] of TTDA_Nodo;\r
+ siguientes : array [ 1 .. TTDA_MAX_CURSOR ] of TTDA_Puntero;\r
+ primero_dispo : TTDA_Puntero;\r
+end;\r
+\r
+{ PUNTEROS }\r
+TTDA_Almac = record\r
+ { esta vacia porque logicamente esta administracion la hace el lenguaje }\r
+end;\r
+\r
+\r
+{ ========= }\r
+{ INTERFASE }\r
+\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+{ PRE : 'almac' no esta inicializado }\r
+{ POST: 'almac' esta inicializado y vacio }\r
+procedure TTDA_Almac_Inicializar( VAR almac : TTDA_Almac );\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces retorna TRUE y sino FALSE }\r
+function TTDA_Almac_HayLugar( almac : TTDA_Almac ): boolean;\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+{ PRE : 'almac' esta inicializado }\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+procedure TTDA_Almac_Reservar( VAR almac : TTDA_Almac; VAR puntero : TTDA_Puntero );\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+procedure TTDA_Almac_Liberar( VAR almac : TTDA_Almac; VAR puntero : TTDA_Puntero );\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+procedure TTDA_Almac_Acceder( almac : TTDA_Almac; puntero : TTDA_Puntero; VAR elemento : TTDA_Nodo );\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+procedure TTDA_Almac_Modificar( VAR almac : TTDA_Almac; puntero : TTDA_Puntero; elemento : TTDA_Nodo );\r
+\r
+\r
+implementation\r
+\r
+{ CURSORES }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+procedure TTDA_Almac_Inicializar( VAR almac : TTDA_Almac );\r
+var i : TTDA_Puntero;\r
+begin\r
+ almac.primero_dispo := 1;\r
+ for i := 1 to TTDA_CURSOR_MAX - 1 do\r
+ begin\r
+ siguientes[i] := i + 1;\r
+ end;\r
+ siguientes[TTDA_CURSOR_MAX] := TTDA_Nulo;\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+function TTDA_Almac_HayLugar( almac : TTDA_Almac ): boolean;\r
+begin\r
+ TTDA_Almac_HayLugar := almac.primero_dispo = TTDA_Nulo;\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+procedure TTDA_Almac_Reservar( VAR almac : TTDA_Almac; VAR puntero : TTDA_Puntero );\r
+begin\r
+ if not TTDA_Almac_HayLugar( almac )\r
+ then\r
+ puntero := TTDA_Nulo\r
+ else begin\r
+ puntero := almac.primero_dispo;\r
+ almac.primero_dispo := almac.siguientes[ puntero ];\r
+ end;\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+procedure TTDA_Almac_Liberar( VAR almac : TTDA_Almac; VAR puntero : TTDA_Puntero );\r
+begin\r
+ almac.siguientes[ puntero ] := almac.primero_dispo;\r
+ almac.primero_dispo := puntero;\r
+ puntero := TTDA_Nulo;\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+procedure TTDA_Almac_Acceder( almac : TTDA_Almac; puntero : TTDA_Puntero; VAR elemento : TTDA_Nodo );\r
+begin\r
+ elemento := almac.almacenamiento[ puntero ];\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+procedure TTDA_Almac_Modificar( VAR almac : TTDA_Almac; puntero : TTDA_Puntero; elemento : TTDA_Nodo );\r
+begin\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+end;\r
+\r
+\r
+\r
+{ PUNTEROS }\r
+{ ========================================================================== }\r
+{ inicializar el almacenamiento }\r
+procedure TTDA_Almac_Inicializar( VAR almac : TTDA_Almac );\r
+begin\r
+end;\r
+\r
+{ ========================================================================== }\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+function TTDA_Almac_HayLugar( almac : TTDA_Almac ): boolean;\r
+begin\r
+ { aca habria que hacer alguna consulta a la memoria libre }\r
+ TTDA_Almac_HayLugar := true;\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+procedure TTDA_Almac_Reservar( VAR almac : TTDA_Almac; VAR puntero : TTDA_Puntero );\r
+begin\r
+ puntero := new( TTDA_Nodo );\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ liberar un elemento del almacenamiento }\r
+procedure TTDA_Almac_Liberar( VAR almac : TTDA_Almac; VAR puntero : TTDA_Puntero );\r
+begin\r
+ dispose( puntero );\r
+ puntero := TTDA_Nulo;\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+procedure TTDA_Almac_Acceder( almac : TTDA_Almac; puntero : TTDA_Puntero; VAR elemento : TTDA_Nodo );\r
+begin\r
+ elemento := puntero^;\r
+end;\r
+\r
+\r
+{ ========================================================================== }\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+procedure TTDA_Almac_Modificar( VAR almac : TTDA_Almac; puntero : TTDA_Puntero; elemento : TTDA_Nodo );\r
+begin\r
+ puntero^ := elemento;\r
+end;\r
+\r
+\r
+{ fin de la unidad }\r
+end.\r
--- /dev/null
+unit tda_gral;\r
+{ funciones y datos y tipo generales de los TDA de almacenamiento }\r
+\r
+interface\r
+\r
+{ aca se define el famoso tipo_elem }\r
+type\r
+ TipoDNI = 1000000..50000000;\r
+ Persona = record\r
+ DNI : TipoDNI;\r
+ Nombre : String;\r
+ Apellido : String;\r
+ end;\r
+\r
+ Tipo_Clave = TipoDNI;\r
+ Tipo_Elem = Persona;\r
+\r
+{ esta funcion devuelve la clave de un elemento almacenado }\r
+{ PRE : ninguna }\r
+{ POST: devuelve la clave de un elemento E }\r
+function Devolver_Clave_Elem( E: Tipo_Elem): Tipo_Clave;\r
+\r
+{ este procedimiento se usa en recorridos e imprime los datos del elemento }\r
+{ PRE : ninguna }\r
+{ POST: se imprimieron los datos }\r
+procedure Procesar_Elem_Recorrido( var e: Tipo_Elem);\r
+\r
+{ compara dos elementos completos para ver si cumplen con el criterio o no }\r
+FUNCTION Comparar_Elementos( a: Tipo_Elem; b: Tipo_Elem ): boolean;\r
+\r
+implementation\r
+\r
+{ esta funcion devuelve la clave de un elemento almacenado }\r
+function Devolver_Clave_Elem( E: Tipo_Elem): Tipo_Clave;\r
+begin\r
+ Devolver_Clave_Elem := E.DNI;\r
+end;\r
+\r
+{ este procedimiento se usa en recorridos e imprime los datos del elemento }\r
+procedure Procesar_Elem_Recorrido( var e: Tipo_Elem);\r
+BEGIN\r
+ \r
+END;\r
+\r
+{ compara dos elementos completos para ver si cumplen con el criterio o no }\r
+FUNCTION Comparar_elementos( a: Tipo_Elem; b: Tipo_Elem ): boolean;\r
+BEGIN\r
+ IF a.DNI = b.DNI \r
+ THEN \r
+ Comparar_Elementos := true\r
+ ELSE \r
+ Comparar_Elementos := false;\r
+END;\r
+\r
+end.\r
--- /dev/null
+program comandos;\r
+{\r
+ TRABAJO PRACTICO NUMERO 1\r
+ 1er Cuatrimestre 2000\r
+ Este programa sirve para generar los archivos binarios de entrada\r
+ para el programa del TP nro 1, ya que en clase se acordo hacerlos\r
+ binarios. Hubiera sido mas comodo que fueran de texto, pero que le\r
+ vamos a hacer.\r
+ Parametros: archivo de salida\r
+\r
+}\r
+\r
+Type\r
+ T_registro_entrada = record\r
+ Comando: string[2];\r
+ DNI: string[8];\r
+ Nombre: string[40];\r
+ Movimiento: string[1];\r
+ DNI_hasta: string[8];\r
+ End;\r
+\r
+\r
+Var outfile: file of T_registro_entrada;\r
+ r: T_registro_entrada;\r
+\r
+begin\r
+\r
+ If paramcount >= 1 then begin\r
+ Writeln('Archivo de Salida :',ParamStr(1));\r
+\r
+ Assign(outfile, ParamStr(1));\r
+\r
+ Rewrite (outfile);\r
+\r
+ { readln(r.comando);{, r.dni, r.nombre);}\r
+\r
+ while true do begin\r
+\r
+ write('COMANDO :');\r
+ readln(r.comando);\r
+ if r.comando = '' then exit;\r
+\r
+ write('DNI :');\r
+ readln(r.dni);\r
+ if r.dni = '' then r.dni := '*';\r
+\r
+ write('NOMBRE :');\r
+ readln(r.nombre);\r
+ if r.nombre = '' then r.nombre := '*';\r
+\r
+ write('MOVIMIENTO p/a/s/u:');\r
+ readln(r.movimiento);\r
+ if r.movimiento = '' then r.movimiento := '*';\r
+\r
+ write('DNI_HASTA :');\r
+ readln(r.dni_hasta);\r
+ if r.dni_hasta = '' then r.dni_hasta := '*';\r
+\r
+\r
+ write(outfile, r);\r
+\r
+ end;\r
+\r
+ end\r
+ else writeln ('Numero de parametros incorrecto. Uso comandos <archivo_de_salida>');\r
+\r
+\r
+end.\r
+\r
--- /dev/null
+unit ldoblec;\r
+\r
+\r
+\r
+{\r
+\r
+ IMPLEMENTACION : LISTAS DOBLEMENTE ENLAZADAS\r
+\r
+ ALMACENAMIENTO : CURSORES\r
+\r
+\r
+\r
+}\r
+\r
+\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+(*\r
+Este c¢digo esta basado en la implementacion de listas simples dada\r
+por la c tedra.\r
+*)\r
+\r
+interface\r
+\r
+\r
+\r
+{ usa las funciones generales de TDAs }\r
+\r
+uses tda_gral;\r
+\r
+\r
+\r
+{ maximo tamano del cursor }\r
+\r
+const LSC_MAX_CURSOR = 100;\r
+\r
+\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+\r
+TYPE\r
+\r
+ LSC_puntero = Integer;\r
+\r
+\r
+\r
+const\r
+\r
+ LSC_nulo : LSC_puntero = 0;\r
+\r
+\r
+\r
+type\r
+\r
+\r
+\r
+ LSC_nodo = RECORD\r
+\r
+ Elem : Tipo_Elem; {definido en TDA_GRAL}\r
+\r
+ Sig,Ant : LSC_puntero;\r
+\r
+ END;\r
+\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+\r
+ LSC_Almac = record\r
+\r
+ almacenamiento : array [ 1 .. LSC_MAX_CURSOR ] of LSC_Nodo;\r
+\r
+ siguientes : array [ 1 .. LSC_MAX_CURSOR ] of LSC_Puntero;\r
+\r
+ anteriores : array [ 1 .. LSC_MAX_CURSOR ] of LSC_Puntero;\r
+\r
+ {decia: primero_dispo : TTDA_Puntero;}\r
+ primero_dispo: LSC_puntero;\r
+\r
+ end;\r
+\r
+\r
+\r
+\r
+\r
+ LSC_Lista_Simple_C = RECORD\r
+\r
+ almac : LSC_Almac;\r
+\r
+ primero: LSC_puntero;\r
+\r
+ corriente : LSC_puntero;\r
+\r
+ END;\r
+\r
+\r
+\r
+ LSC_movimiento = (LSC_primero, LSC_ultimo, LSC_siguiente,LSC_anterior );\r
+\r
+\r
+\r
+\r
+\r
+{ ========= }\r
+\r
+{ INTERFACE }\r
+\r
+\r
+\r
+\r
+\r
+PROCEDURE LSC_Inicializar ( VAR l: LSC_Lista_Simple_C );\r
+\r
+FUNCTION LSC_vacio( l: LSC_Lista_Simple_C): BOOLEAN;\r
+\r
+FUNCTION LSC_lleno( l: LSC_Lista_Simple_C): BOOLEAN;\r
+\r
+\r
+\r
+PROCEDURE LSC_elem_cte ( l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+\r
+PROCEDURE LSC_modif_cte ( VAR l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+\r
+PROCEDURE LSC_mover_cte ( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; VAR error: BOOLEAN );\r
+\r
+PROCEDURE LSC_borrar_cte ( VAR l: LSC_Lista_Simple_C );\r
+\r
+PROCEDURE LSC_insertar ( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; var e: Tipo_Elem );\r
+\r
+PROCEDURE LSC_vaciar ( VAR l: LSC_Lista_Simple_C );\r
+\r
+PROCEDURE LSC_copiar ( a: LSC_Lista_Simple_C; VAR b: LSC_Lista_Simple_C );\r
+\r
+\r
+\r
+implementation\r
+\r
+\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+\r
+{ ========================================================================== }\r
+\r
+{ inicializar el almacenamiento }\r
+\r
+{ PRE : 'almac' no esta inicializado }\r
+\r
+{ POST: 'almac' esta inicializado y vacio }\r
+\r
+procedure LSC_Almac_Inicializar( VAR almac : LSC_Almac );\r
+\r
+var i : LSC_Puntero;\r
+\r
+begin\r
+\r
+ almac.primero_dispo := 1;\r
+\r
+{ almac.anteriores[1] := LSC_Nulo;}\r
+\r
+ for i := 1 to LSC_MAX_CURSOR - 1 do\r
+\r
+ begin\r
+\r
+ almac.siguientes[i] := i + 1;\r
+{ almac.anteriores[i+1] := i;}\r
+\r
+ end;\r
+\r
+ almac.siguientes[LSC_MAX_CURSOR] := LSC_Nulo;\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+\r
+{ PRE : 'almac' esta inicializado }\r
+\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+\r
+ entonces retorna TRUE y sino FALSE }\r
+{MODIFICACION: Retornaba false si NO habia lugar. Ademas el\r
+parametro ahora viene por referencia.}\r
+\r
+function LSC_Almac_HayLugar( var almac : LSC_Almac ): boolean;\r
+\r
+begin\r
+\r
+ LSC_Almac_HayLugar := NOT (almac.primero_dispo = LSC_Nulo);\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+\r
+{ PRE : 'almac' esta inicializado }\r
+\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+\r
+procedure LSC_Almac_Reservar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+\r
+begin\r
+\r
+ if not LSC_Almac_HayLugar( almac )\r
+\r
+ then\r
+\r
+ puntero := LSC_Nulo\r
+\r
+ else begin\r
+\r
+ puntero := almac.primero_dispo;\r
+\r
+ almac.primero_dispo := almac.siguientes[ puntero ];\r
+\r
+ end;\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ liberar un elemento del almacenamiento }\r
+\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+\r
+procedure LSC_Almac_Liberar( VAR almac : LSC_Almac; VAR puntero : LSC_Puntero );\r
+\r
+begin\r
+\r
+ almac.siguientes[ puntero ] := almac.primero_dispo;\r
+\r
+ almac.primero_dispo := puntero;\r
+\r
+ puntero := LSC_Nulo;\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+\r
+procedure LSC_Almac_Acceder( almac : LSC_Almac; puntero : LSC_Puntero; VAR elemento : LSC_Nodo );\r
+\r
+begin\r
+\r
+ elemento := almac.almacenamiento[ puntero ];\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+\r
+procedure LSC_Almac_Modificar( VAR almac : LSC_Almac; puntero : LSC_Puntero; elemento : LSC_Nodo );\r
+\r
+begin\r
+\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+\r
+end;\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+\r
+\r
+PROCEDURE LSC_Inicializar ( VAR l: LSC_Lista_Simple_C );\r
+\r
+BEGIN\r
+\r
+ LSC_Almac_Inicializar( l.almac );\r
+\r
+ l.primero := LSC_Nulo;\r
+\r
+ l.corriente := LSC_Nulo;\r
+\r
+END;\r
+\r
+\r
+\r
+FUNCTION LSC_vacio( l: LSC_Lista_Simple_C): BOOLEAN;\r
+\r
+BEGIN\r
+\r
+ LSC_vacio := ( l.Primero = LSC_Nulo);\r
+\r
+END;\r
+\r
+\r
+\r
+FUNCTION LSC_lleno( l: LSC_Lista_Simple_C): BOOLEAN;\r
+\r
+BEGIN\r
+\r
+ LSC_lleno := not LSC_Almac_HayLugar( l.almac );\r
+\r
+END;\r
+\r
+\r
+\r
+PROCEDURE LSC_elem_cte ( l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+\r
+var n : LSC_Nodo;\r
+\r
+BEGIN\r
+\r
+ { accedo al almacenamiento por el nodo corriente }\r
+\r
+ LSC_Almac_Acceder ( l.almac, l.Corriente, n );\r
+\r
+\r
+\r
+ { y se lo asigno al parametro }\r
+\r
+ e := n.Elem;\r
+\r
+END;\r
+\r
+\r
+\r
+PROCEDURE LSC_modif_cte ( VAR l: LSC_Lista_Simple_C; VAR e: Tipo_Elem);\r
+\r
+var n : LSC_Nodo;\r
+\r
+BEGIN\r
+\r
+ { accedo al almacenamiento por el nodo corriente }\r
+\r
+ LSC_Almac_Acceder ( l.almac, l.Corriente, n );\r
+\r
+\r
+\r
+ { y la asigno al parametro }\r
+\r
+ n.Elem := e;\r
+\r
+\r
+\r
+ { y modifico el almacenamiento }\r
+\r
+ LSC_Almac_Modificar ( l.almac, l.Corriente, n );\r
+\r
+\r
+\r
+END;\r
+\r
+\r
+\r
+PROCEDURE LSC_mover_cte ( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; VAR error: BOOLEAN );\r
+\r
+VAR n : LSC_Nodo; prueba: integer ;\r
+\r
+BEGIN\r
+\r
+ error := FALSE;\r
+\r
+ CASE m OF\r
+\r
+ LSC_primero:\r
+\r
+ l.Corriente := l.Primero;\r
+\r
+ LSC_anterior:\r
+\r
+ BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+\r
+ LSC_Almac_Acceder ( l.almac, l.Corriente, n );\r
+\r
+\r
+\r
+ {modificado, decia n.siguiente}\r
+ IF n.ant = LSC_Nulo\r
+\r
+\r
+ THEN\r
+\r
+ error := TRUE\r
+\r
+ ELSE\r
+\r
+ l.corriente := n.ant;\r
+\r
+\r
+ END; {BEGIN}\r
+\r
+ LSC_siguiente:\r
+ BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+ LSC_Almac_Acceder ( l.almac, l.Corriente, n );\r
+\r
+\r
+\r
+ {modificado, decia n.siguiente}\r
+ IF n.sig = LSC_Nulo\r
+\r
+\r
+ THEN\r
+\r
+ error := TRUE\r
+\r
+ ELSE\r
+\r
+{decia: l.corriente := n.siguiente;}\r
+ l.corriente := n.sig;\r
+\r
+ END; {BEGIN}\r
+\r
+ {Implementacion recursiva de mover al ultimo,para listas\r
+ doblemente enlazadas.}\r
+\r
+ LSC_ultimo:\r
+ BEGIN\r
+ { accedo al almacenamiento por el nodo corriente }\r
+\r
+\r
+ LSC_mover_cte ( l, lsc_siguiente, error);\r
+\r
+ IF error <> true then\r
+\r
+ LSC_mover_cte ( l, lsc_ultimo, error);\r
+\r
+ error:= false\r
+\r
+ END; {BEGIN}\r
+\r
+ END;{CASE}\r
+\r
+END; {PROCEDURE}\r
+\r
+\r
+\r
+PROCEDURE LSC_borrar_cte ( VAR l: LSC_Lista_Simple_C );\r
+\r
+VAR n : LSC_Nodo;\r
+\r
+ tmp,tmp2 : LSC_Nodo;\r
+\r
+ tmpp : LSC_Puntero;\r
+\r
+BEGIN\r
+\r
+ if l.corriente = l.primero then begin\r
+\r
+ LSC_Almac_Acceder( l.almac, l.primero, n );\r
+\r
+ l.primero := n.Sig;\r
+\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+\r
+ l.corriente := l.primero;\r
+\r
+ {Asigno a l.primero^.ant un valor LSC_Nulo, en las siguientes 3 lineas}\r
+\r
+ LSC_Almac_Acceder( l.almac, l.primero, tmp );\r
+\r
+ tmp.ant:= LSC_Nulo;\r
+\r
+ LSC_Almac_Modificar( l.almac, l.primero, tmp );\r
+\r
+ end\r
+\r
+ else begin\r
+\r
+ tmpp := l.primero;\r
+\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+\r
+ while( tmp.sig <> l.corriente ) do begin\r
+\r
+ tmpp := tmp.sig;\r
+\r
+ LSC_Almac_Acceder( l.almac, tmpp, tmp );\r
+\r
+ end;\r
+\r
+ LSC_Almac_Acceder( l.almac, l.corriente, n );\r
+\r
+ tmp.sig := n.Sig;\r
+\r
+ LSC_Almac_Modificar( l.almac, tmpp, tmp ); {creo que esto faltaba}\r
+\r
+ {Agregado: este IF modifica el anterior del siguiente, siempre\r
+ que corriente no sea el ultimo}\r
+\r
+ IF n.sig <> LSC_Nulo THEN\r
+ BEGIN\r
+\r
+ LSC_Almac_Acceder( l.almac, n.sig, tmp2 );\r
+\r
+ tmp2.ant:= tmpp;\r
+\r
+ LSC_Almac_Modificar( l.almac, tmp.sig, tmp2 );\r
+ END;\r
+\r
+ LSC_Almac_Liberar( l.almac, l.corriente );\r
+\r
+ l.corriente := tmpp;\r
+\r
+ end;\r
+\r
+END;\r
+\r
+\r
+\r
+PROCEDURE LSC_insertar ( VAR l: LSC_Lista_Simple_C; m: LSC_movimiento; var e: Tipo_Elem );\r
+\r
+VAR\r
+\r
+ p : LSC_puntero;\r
+\r
+ n : LSC_Nodo;\r
+\r
+ ant,sig : LSC_Nodo;\r
+\r
+ np: LSC_Puntero;\r
+\r
+BEGIN\r
+\r
+ n.ant:= lsc_nulo;\r
+\r
+ LSC_Almac_Reservar( l.almac, np );\r
+\r
+ n.Elem := e;\r
+\r
+ CASE m OF\r
+\r
+ LSC_primero:\r
+\r
+ BEGIN\r
+\r
+ {Agregado: cambiar l.primero^.ant a el nuevo nodo}\r
+ IF l.primero <> LSC_NULO THEN\r
+ BEGIN\r
+ LSC_Almac_Acceder( l.almac, l.primero, ant );\r
+\r
+ ant.ant := np;\r
+\r
+ LSC_Almac_Modificar( l.almac, l.primero, ant );\r
+ END;\r
+\r
+ n.sig := l.primero;\r
+\r
+ LSC_Almac_Modificar ( l.almac, np, n );\r
+\r
+ l.primero := np;\r
+\r
+ END;\r
+\r
+ LSC_anterior:\r
+\r
+ BEGIN\r
+\r
+\r
+ LSC_Almac_Acceder( l.almac, l.corriente, sig );\r
+\r
+ n.sig := l.corriente;\r
+ n.ant := sig.ant;\r
+\r
+ sig.ant := np;\r
+\r
+\r
+ IF n.ant <> lsc_nulo then begin\r
+\r
+ LSC_Almac_Acceder( l.almac, n.ant, ant );\r
+\r
+ ant.sig := np;\r
+\r
+ LSC_Almac_Modificar( l.almac, n.ant, ant );\r
+\r
+ end;\r
+\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+\r
+ LSC_Almac_Modificar( l.almac, l.corriente, sig );\r
+\r
+ If l.corriente = L.primero then l.primero:= np;\r
+\r
+\r
+ END;{BEGIN}\r
+\r
+ LSC_siguiente:\r
+\r
+ BEGIN\r
+\r
+\r
+ LSC_Almac_Acceder( l.almac, l.corriente, ant );\r
+\r
+ n.sig := ant.sig;\r
+ n.ant := l.corriente;\r
+\r
+ ant.sig := np;\r
+\r
+ {Agregado: cambia n.sig^.ant a el nuevo nodo}\r
+\r
+ IF n.sig <> lsc_nulo then begin\r
+\r
+ LSC_Almac_Acceder( l.almac, n.sig, sig );\r
+\r
+ sig.ant := np;\r
+\r
+ LSC_Almac_Modificar( l.almac, n.sig, sig );\r
+\r
+ end;\r
+\r
+ LSC_Almac_Modificar( l.almac, np, n );\r
+\r
+ LSC_Almac_Modificar( l.almac, l.corriente, ant );\r
+\r
+\r
+\r
+ END;{BEGIN}\r
+ END;{CASE}\r
+\r
+\r
+\r
+ l.Corriente := np;\r
+\r
+\r
+\r
+END;\r
+\r
+\r
+\r
+PROCEDURE LSC_vaciar ( VAR l: LSC_Lista_Simple_C );\r
+\r
+VAR np : LSC_Puntero;\r
+\r
+ n : LSC_Nodo;\r
+\r
+BEGIN\r
+\r
+ LSC_Inicializar(l); {esta es otra forma de vaciar una lista, ya que la\r
+ original no estoy seguro de que funciona}\r
+\r
+\r
+(* np := l.primero;\r
+\r
+ while( np <> LSC_Nulo ) do begin\r
+\r
+ LSC_Almac_Acceder( l.almac, np, n );\r
+\r
+ LSC_Almac_Liberar( l.almac, np );\r
+\r
+ np := n.sig;\r
+\r
+ end;\r
+\r
+ l.primero := LSC_Nulo;\r
+\r
+ l.corriente := LSC_Nulo;\r
+*)\r
+\r
+END;\r
+\r
+\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+\r
+PROCEDURE LSC_copiar ( a : LSC_Lista_Simple_C; VAR b : LSC_Lista_Simple_C );\r
+\r
+VAR np,mp,tmpp : LSC_Puntero;\r
+\r
+ n,m : LSC_Nodo;\r
+\r
+BEGIN\r
+\r
+{ if a.primero = LSC_Nulo then return; {return no existe}\r
+\r
+ if a.primero = LSC_Nulo then exit;\r
+\r
+\r
+ np := a.primero;\r
+\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+\r
+\r
+ LSC_Almac_Reservar( b.almac, mp );\r
+\r
+ b.primero := mp;\r
+\r
+ b.corriente := mp;\r
+\r
+ m.elem := n.elem;\r
+\r
+ m.ant := n.ant; {agregado para listas dobles}\r
+\r
+\r
+ while( n.sig <> LSC_Nulo ) do begin\r
+\r
+\r
+\r
+ LSC_Almac_Reservar( b.almac, tmpp );\r
+\r
+ m.sig := tmpp;\r
+\r
+ LSC_Almac_Modificar( b.almac, mp, m );\r
+\r
+\r
+ np := n.sig;\r
+\r
+ LSC_Almac_Acceder( a.almac, np, n );\r
+\r
+\r
+\r
+ mp := tmpp;\r
+\r
+ m.elem := n.elem;\r
+\r
+ m.ant:= n.ant\r
+\r
+\r
+ end;\r
+\r
+ m.sig := LSC_Nulo;\r
+\r
+ LSC_Almac_Modificar( b.almac, mp, m );\r
+\r
+END;\r
+\r
+\r
+\r
+end.\r
+\r
--- /dev/null
+El Programa primcipal es TP1.PAS\r
+\r
+Para generar un archivo de entrada se usa el Programa comandos. \r
+Los comandos introducidos deben estar en MAYUSCULAS.\r
+Se incluye en este disco un archivo de entrada llamado prueba,\r
+y el archivo outfile.txt, que fue generado por este. Los registros que\r
+se insertan al usar prueba tienen como clave letras en vez de numeros de\r
+dni, porque el campo es de caracteres y esto sirve para ver el resultado\r
+de la order OR (ordenar).\r
+\r
+Uso del programa:\r
+\r
+ TP1.exe <infile> <outfile>\r
+\r
+ Ejemplo: TP1 in.bin outfile.txt\r
+\r
+Uso de comandos:\r
+\r
+ comandos <file>\r
+ donde <file> es el nombre del archivo de entrada para TP1.exe\r
+ que será creado.\r
+\r
--- /dev/null
+Archivo de Entrada:prueba\r
+Archivo de Salida :outfile.txt\r
+\r
+\r
+>IN V MARIANO P *\r
+\r
+>IN L PEPE S *\r
+\r
+>IN K JUAN P *\r
+\r
+>IN B HERNAN U *\r
+\r
+>IN A PEDRO U *\r
+\r
+>LS * * * *\r
+ K - JUAN\r
+ V - MARIANO\r
+ L - PEPE\r
+ B - HERNAN\r
+ A - PEDRO\r
+\r
+>LC * * * *\r
+ A - PEDRO\r
+\r
+>IN F FEDERICO S *\r
+\r
+>LS * * * *\r
+ K - JUAN\r
+ V - MARIANO\r
+ L - PEPE\r
+ B - HERNAN\r
+ A - PEDRO\r
+ F - FEDERICO\r
+\r
+>LC * * * *\r
+ F - FEDERICO\r
+\r
+>OR * * * *\r
+\r
+>LC * * * *\r
+ F - FEDERICO\r
+\r
+>LS * * * *\r
+ A - PEDRO\r
+ B - HERNAN\r
+ F - FEDERICO\r
+ K - JUAN\r
+ L - PEPE\r
+ V - MARIANO\r
+\r
+>IO G GASTON * *\r
+\r
+>LC * * * *\r
+ G - GASTON\r
+\r
+>LS * * * *\r
+ A - PEDRO\r
+ B - HERNAN\r
+ F - FEDERICO\r
+ G - GASTON\r
+ K - JUAN\r
+ L - PEPE\r
+ V - MARIANO\r
+\r
+>MO T TOMAS * *\r
+\r
+>LC * * * *\r
+ T - TOMAS\r
+\r
+>LS * * * *\r
+ A - PEDRO\r
+ B - HERNAN\r
+ F - FEDERICO\r
+ G - GASTON\r
+ K - JUAN\r
+ L - PEPE\r
+ T - TOMAS\r
+\r
+>OR * * * *\r
+\r
+>LC * * * *\r
+ T - TOMAS\r
+\r
+>BO * * * *\r
+\r
+>LS * * * *\r
+ A - PEDRO\r
+ B - HERNAN\r
+ F - FEDERICO\r
+ G - GASTON\r
+ K - JUAN\r
+ L - PEPE\r
+\r
+>LC * * * *\r
+ L - PEPE\r
+\r
+>LI * * * *\r
+\r
+>LS * * * *\r
+TABLA VACIA\r
--- /dev/null
+unit pila_C;\r
+\r
+\r
+\r
+{\r
+\r
+ IMPLEMENTACION : pilas\r
+\r
+ ALMACENAMIENTO : CURSORES\r
+\r
+ MODIFICADO PARA QUE COMPILE, y un par de errores que tenia (estan marcados)\r
+\r
+}\r
+\r
+\r
+\r
+{ ACLARACIONES : implementamos tambien aca los cursores porque son para estos nodos en particular }\r
+\r
+interface\r
+\r
+\r
+\r
+{ usa las funciones generales de TDAs }\r
+\r
+uses tda_gral;\r
+\r
+\r
+\r
+{ maximo tamano del cursor }\r
+\r
+const PILAC_MAX_CURSOR = 100;\r
+\r
+\r
+\r
+{ tipos propios de la lista para definir el cursor }\r
+\r
+TYPE\r
+\r
+ PILAC_puntero = integer;\r
+\r
+\r
+\r
+const\r
+\r
+ PILAC_nulo : PILAC_puntero = 0;\r
+\r
+\r
+\r
+type\r
+\r
+\r
+\r
+ PILAC_nodo = RECORD\r
+\r
+ Elem : Tipo_Elem;\r
+\r
+ Sig : PILAC_puntero;\r
+\r
+ END;\r
+\r
+\r
+\r
+\r
+\r
+ { ahora le toca definir el cursor }\r
+\r
+ PILAC_Almac = record\r
+\r
+ almacenamiento : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Nodo;\r
+\r
+ siguientes : array [ 1 .. PILAC_MAX_CURSOR ] of PILAC_Puntero;\r
+\r
+ primero_dispo : PILAC_puntero;\r
+\r
+ end;\r
+\r
+\r
+\r
+\r
+\r
+ PILAC_Pila = RECORD\r
+\r
+ almac : PILAC_Almac;\r
+\r
+ primero: PILAC_puntero;\r
+\r
+ END;\r
+\r
+\r
+\r
+\r
+\r
+{ ========= }\r
+\r
+{ INTERFASE }\r
+\r
+\r
+\r
+\r
+\r
+PROCEDURE PILAC_Inicializar ( VAR l: PILAC_Pila );\r
+\r
+FUNCTION PILAC_vacio( l: PILAC_Pila): BOOLEAN;\r
+\r
+FUNCTION PILAC_lleno( l: PILAC_Pila): BOOLEAN;\r
+\r
+\r
+\r
+PROCEDURE PILAC_poner ( VAR l: PILAC_Pila; VAR e: Tipo_Elem );\r
+\r
+PROCEDURE PILAC_sacar ( VAR l: PILAC_Pila; VAR e: Tipo_Elem);\r
+\r
+PROCEDURE PILAC_vaciar ( VAR l: PILAC_Pila );\r
+\r
+PROCEDURE PILAC_copiar ( a: PILAC_Pila; VAR b: PILAC_Pila );\r
+\r
+\r
+\r
+implementation\r
+\r
+\r
+\r
+{ CURSORES DE ESTA IMPLEMENTACION }\r
+\r
+{ ========================================================================== }\r
+\r
+{ inicializar el almacenamiento }\r
+\r
+{ PRE : 'almac' no esta inicializado }\r
+\r
+{ POST: 'almac' esta inicializado y vacio }\r
+\r
+procedure PILAC_Almac_Inicializar( VAR almac : PILAC_Almac );\r
+\r
+var i : PILAC_Puntero;\r
+\r
+begin\r
+\r
+ almac.primero_dispo := 1;\r
+\r
+ for i := 1 to PILAC_MAX_CURSOR - 1 do\r
+\r
+ begin\r
+\r
+ almac.siguientes[i] := i + 1;\r
+\r
+ end;\r
+\r
+ almac.siguientes[PILAC_MAX_CURSOR] := PILAC_Nulo;\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ saber si hay lugar para reservar un nuevo elemento en el almacenamiento }\r
+\r
+{ PRE : 'almac' esta inicializado }\r
+\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+\r
+ entonces retorna TRUE y sino FALSE }\r
+{ANDABA AL REVES, CORREGIDO}\r
+\r
+\r
+function PILAC_Almac_HayLugar( almac : PILAC_Almac ): boolean;\r
+\r
+begin\r
+\r
+ PILAC_Almac_HayLugar := NOT (almac.primero_dispo = PILAC_Nulo);\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ el pedido de un nuevo elemento al almacenamiento }\r
+\r
+{ PRE : 'almac' esta inicializado }\r
+\r
+{ POST: si hay lugar en 'almac' para un nuevo elemento,\r
+\r
+ entonces 'puntero' tiene una referencia a un nuevo elemento del almacenamiento\r
+\r
+ sino 'puntero' tiene el valor TTDA_Nulo }\r
+\r
+procedure PILAC_Almac_Reservar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
+\r
+begin\r
+\r
+ if not PILAC_Almac_HayLugar( almac )\r
+\r
+ then\r
+\r
+ puntero := PILAC_Nulo\r
+\r
+ else begin\r
+\r
+ puntero := almac.primero_dispo;\r
+\r
+ almac.primero_dispo := almac.siguientes[ puntero ];\r
+\r
+ end;\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ liberar un elemento del almacenamiento }\r
+\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+\r
+{ POST: 'almac' libero el nodo apuntado por 'puntero' y 'puntero' vale TTDA_Nulo }\r
+\r
+procedure PILAC_Almac_Liberar( VAR almac : PILAC_Almac; VAR puntero : PILAC_Puntero );\r
+\r
+begin\r
+\r
+ almac.siguientes[ puntero ] := almac.primero_dispo;\r
+\r
+ almac.primero_dispo := puntero;\r
+\r
+ puntero := PILAC_Nulo;\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ acceder al elemento del almacenamiento apuntado por un puntero }\r
+\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+\r
+{ POST: 'elemento' tiene una copia del elemento apuntado por 'puntero' }\r
+\r
+procedure PILAC_Almac_Acceder( almac : PilaC_Almac; puntero : PILAC_Puntero; VAR elemento : PILAC_Nodo );\r
+\r
+begin\r
+\r
+ elemento := almac.almacenamiento[ puntero ];\r
+\r
+end;\r
+\r
+\r
+\r
+{ ========================================================================== }\r
+\r
+{ modificar el elemento del almacenamiento apuntado por un puntero }\r
+\r
+{ PRE : 'almac' esta inicializado y 'puntero' fue pedido al almacenamiento }\r
+\r
+{ POST: el elemento de 'almac' apuntado por 'puntero' tiene una copia de 'elemento' }\r
+\r
+procedure PILAC_Almac_Modificar( VAR almac : PILAC_Almac; puntero : PILAC_Puntero; elemento : PILAC_Nodo );\r
+\r
+begin\r
+\r
+ almac.almacenamiento[ puntero ] := elemento;\r
+\r
+end;\r
+\r
+\r
+\r
+\r
+\r
+\r
+\r
+{ Estas son los dos procedimientos principales de la aplicación }\r
+\r
+\r
+\r
+PROCEDURE PILAC_Inicializar ( VAR l: PILAC_Pila );\r
+\r
+BEGIN\r
+\r
+ PILAC_Almac_Inicializar( l.almac );\r
+\r
+ l.primero := PILAC_Nulo;\r
+\r
+END;\r
+\r
+\r
+\r
+FUNCTION PILAC_vacio( l: PILAC_Pila): BOOLEAN;\r
+\r
+BEGIN\r
+\r
+ PILAC_vacio := ( l.Primero = PILAC_Nulo);\r
+\r
+END;\r
+\r
+\r
+\r
+FUNCTION PILAC_lleno( l: PILAC_Pila): BOOLEAN;\r
+\r
+BEGIN\r
+\r
+ PILAC_lleno := not PILAC_Almac_HayLugar( l.almac );\r
+\r
+END;\r
+\r
+\r
+\r
+PROCEDURE PILAC_poner ( VAR l: PILAC_Pila; var e: Tipo_Elem);\r
+\r
+VAR\r
+\r
+ n : PILAC_Nodo;\r
+\r
+ np: PILAC_Puntero;\r
+\r
+BEGIN\r
+\r
+ n.Elem := e;\r
+\r
+ n.sig := l.primero;\r
+\r
+ PILAC_Almac_Reservar( l.almac, np );\r
+\r
+ PILAC_Almac_Modificar( l.almac, np, n );\r
+\r
+ l.primero := np;\r
+\r
+END;\r
+\r
+\r
+\r
+{ pre: no esta vacia }\r
+\r
+PROCEDURE PILAC_sacar ( VAR l: PILAC_Pila; VAR e: Tipo_Elem);\r
+\r
+VAR n : PILAC_Nodo;\r
+\r
+ tmp : PILAC_Nodo;\r
+\r
+ tmpp: PILAC_Puntero;\r
+\r
+BEGIN\r
+\r
+ PILAC_Almac_Acceder( l.almac, l.primero, n );\r
+\r
+ PILAC_Almac_Liberar( l.almac, l.primero );\r
+\r
+ l.primero := n.Sig;\r
+\r
+\r
+\r
+ { y se lo asigno al parametro }\r
+\r
+ e := n.Elem;\r
+\r
+END;\r
+\r
+\r
+\r
+PROCEDURE PILAC_vaciar ( VAR l: PILAC_Pila );\r
+\r
+VAR np : PILAC_Puntero;\r
+\r
+ n : PILAC_Nodo;\r
+\r
+BEGIN\r
+\r
+ np := l.primero;\r
+\r
+ while( np <> PILAC_Nulo ) do begin\r
+\r
+ PILAC_Almac_Acceder( l.almac, np, n );\r
+\r
+ PILAC_Almac_Liberar( l.almac, np );\r
+\r
+ np := n.sig;\r
+\r
+ end;\r
+\r
+ l.primero := PILAC_Nulo;\r
+\r
+END;\r
+\r
+\r
+\r
+{ pre: 'a' y 'b' estan creadas y 'b' esta vacia }\r
+\r
+{ POST: 'b' tiene una copia de los elementos de 'a' y el corriente esta en el primero }\r
+\r
+PROCEDURE PILAC_copiar ( a : PILAC_Pila; VAR b : PILAC_Pila );\r
+\r
+VAR np, mp, tmpp : PILAC_Puntero;\r
+\r
+ n,m : PILAC_Nodo;\r
+\r
+BEGIN\r
+\r
+ if a.primero = PILAC_Nulo then exit;\r
+\r
+ np := a.primero;\r
+\r
+ PILAC_Almac_Acceder( a.almac, np, n );\r
+\r
+\r
+\r
+ PILAC_Almac_Reservar( b.almac, mp );\r
+\r
+ b.primero := mp;\r
+\r
+ m.elem := n.elem;\r
+\r
+\r
+\r
+ while( n.sig <> PILAC_Nulo ) do begin\r
+\r
+\r
+\r
+ PILAC_Almac_Reservar( b.almac, tmpp );\r
+\r
+ m.sig := tmpp;\r
+\r
+ PILAC_Almac_Modificar( b.almac, mp, m );\r
+\r
+\r
+\r
+ np := n.sig;\r
+\r
+ PILAC_Almac_Acceder( a.almac, np, n );\r
+\r
+\r
+\r
+ mp := tmpp;\r
+\r
+ m.elem := n.elem;\r
+\r
+\r
+\r
+ end;\r
+\r
+ m.sig := PILAC_Nulo;\r
+\r
+ PILAC_Almac_Modificar( b.almac, mp, m );\r
+\r
+END;\r
+\r
+\r
+\r
+end.\r
+\r
--- /dev/null
+unit tabla;\r
+\r
+\r
+\r
+{\r
+\r
+ IMPLEMENTACION : TDA_TABLA\r
+\r
+\r
+}\r
+{\r
+POR AHORA COMPILA\r
+}\r
+\r
+interface\r
+\r
+uses TDA_GRAL, ldoblec, pila_C;\r
+\r
+TYPE\r
+\r
+ T_MOVIM = LSC_movimiento;\r
+\r
+ T_CLAVE = Tipo_Clave;\r
+\r
+ T_REGISTRO = Tipo_Elem;\r
+\r
+ T_TABLA = record\r
+\r
+ lista : LSC_Lista_Simple_C; {si bien el nombre dice simple, es una lista doble\r
+ no lo cambie aun para evitar mas errores}\r
+ ordenada: boolean;\r
+\r
+ end; {record}\r
+\r
+\r
+\r
+Procedure T_TABLA_Crear ( var T: T_TABLA);\r
+\r
+Function T_TABLA_Vacia ( T: T_TABLA ) : boolean;\r
+\r
+Function T_TABLA_Llena ( T: T_TABLA ) : boolean;\r
+\r
+Function T_TABLA_Ordenada ( T: T_TABLA ) : boolean;\r
+\r
+Procedure T_TABLA_Elem_Cte ( T: T_TABLA ; var R: T_REGISTRO );\r
+\r
+Procedure T_TABLA_Mover_Cte ( var T: T_TABLA ; M: T_MOVIM; var error: boolean );\r
+\r
+Procedure T_TABLA_Insertar ( var T: T_TABLA ; var R: T_REGISTRO; M: T_MOVIM );\r
+\r
+Procedure T_TABLA_Insertar_O ( var T: T_TABLA ; var R: T_REGISTRO);\r
+\r
+Procedure T_TABLA_Limpiar ( var T: T_TABLA );\r
+\r
+Procedure T_TABLA_Borrar_Cte ( var T: T_TABLA );\r
+\r
+Procedure T_TABLA_Modif_Cte ( var T: T_TABLA ; var R: T_REGISTRO );\r
+\r
+Procedure T_TABLA_Ordenar ( var T: T_TABLA );\r
+\r
+Procedure T_TABLA_Buscar_Clave ( var T: T_TABLA ; C: T_CLAVE; var error :boolean);\r
+\r
+PROCEDURE Buscar_por_Rango(var T: T_TABLA; D, H: T_CLAVE; var L: PILAC_Pila);\r
+\r
+{-------------------------------------}\r
+IMPLEMENTATION\r
+\r
+\r
+Procedure T_TABLA_Crear ( var T: T_TABLA);\r
+{\r
+ PRE :T nunca fue creada.\r
+ POST: T creada y vac¡a.\r
+}\r
+\r
+BEGIN\r
+\r
+ LSC_Inicializar ( t.lista );\r
+\r
+ {una lista vacia esta ordenada}\r
+ t.ordenada := true;\r
+\r
+END;\r
+Function T_TABLA_Vacia ( T: T_TABLA ) : boolean;\r
+{\r
+ PRE :T creada.\r
+ POST: Si T tiene elementos, entonces es FALSE, sino es TRUE.\r
+}\r
+BEGIN\r
+\r
+ T_TABLA_Vacia := LSC_vacio( t.lista );\r
+\r
+END;\r
+\r
+\r
+Function T_TABLA_Llena ( T: T_TABLA ) : boolean;\r
+{\r
+ PRE :T creada.\r
+ POST: Si T tiene lugar para insertar nuevos elementos, entonces es FALSE, sino es TRUE.\r
+}\r
+BEGIN\r
+\r
+ T_TABLA_Llena := LSC_lleno( t.lista );\r
+\r
+END;\r
+\r
+Function T_TABLA_Ordenada ( T: T_TABLA ) : boolean;\r
+{\r
+ PRE :T no vac¡a.\r
+ POST: Si T est ordenada, entonces es verdadero, sino es falso.\r
+}\r
+\r
+BEGIN\r
+\r
+ T_TABLA_Ordenada:= t.ordenada;\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Elem_Cte ( T: T_TABLA ; var R: T_REGISTRO );\r
+{\r
+ PRE :T no vac¡a.\r
+ POST: R contiene el registro corriente.\r
+}\r
+\r
+BEGIN\r
+\r
+ LSC_elem_cte ( t.lista, r);\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Mover_Cte ( var T: T_TABLA ; M: T_MOVIM; var error: boolean );\r
+{\r
+ PRE :T no vac¡a.\r
+ POST: Si M = primero, el nuevo corriente es el primer registro y error es falso.\r
+ Si M = ultimo, el nuevo corriente es el £ltimo registro y error es falso.\r
+ Si M = siguiente, el nuevo corriente es el siguiente registro del actual\r
+ corriente y error es falso. Si el corriente era el £ltimo registro, entonces\r
+ error es verdadero y el corriente sigue siendo el £ltimo registro.\r
+ Si M = anterior, el nuevo corriente es el anterior registro del actual\r
+ corriente y error es falso. Si el corriente era el primer registro, entonces\r
+ error es verdadero y el corriente sigue siendo el primer registro.\r
+\r
+ (Los valores para M son de tipo t_movim)\r
+}\r
+\r
+BEGIN\r
+\r
+LSC_mover_cte ( t.lista, m, error );\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Insertar ( var T: T_TABLA ; var R: T_REGISTRO; M: T_MOVIM );\r
+{\r
+ PRE : T no est llena.\r
+ POST: Si M = primero, R se agreg¢, es el primer registro y el nuevo corriente.\r
+ Si M = ultimo, R se agreg¢, es el £ltimo registro y el nuevo corriente.\r
+ Si M = siguiente, R se agreg¢, es el siguiente registro del corriente, y es el nuevo corriente\r
+ Si M = anterior, R se agreg¢, es el anterior registro del corriente, y es el nuevo corriente.\r
+\r
+ Para no complicar mas la implementacion de la lista doble,\r
+ el insertar al final esta implementado aca\r
+}\r
+\r
+VAR error: boolean;\r
+\r
+BEGIN\r
+\r
+ IF m = LSC_ULTIMO then begin\r
+\r
+ LSC_mover_cte ( t.lista, m, error );\r
+\r
+ {insertar al final no es mas que insertar despues de el ultimo:}\r
+ m:= LSC_siguiente\r
+\r
+ end;\r
+\r
+ LSC_insertar ( t.lista, m, r);\r
+\r
+ t.ordenada:= false\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Insertar_O ( var T: T_TABLA ; var R: T_REGISTRO);\r
+\r
+VAR error: boolean;\r
+ e: t_registro;\r
+\r
+BEGIN\r
+\r
+ IF t.ordenada = true then begin\r
+\r
+ T_TABLA_Buscar_Clave(t, r.dni, error); {no importa si lo encuentra o no}\r
+\r
+ T_TABLA_Elem_Cte( t, e);\r
+\r
+ IF e.dni > r.dni then\r
+ T_TABLA_INSERTAR(t, r, lsc_anterior)\r
+ ELSE\r
+ T_TABLA_INSERTAR(t, r, lsc_siguiente);\r
+{*1*}\r
+\r
+ t.ordenada:= true {insertar lo deja en false}\r
+ END;\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Limpiar ( var T: T_TABLA );\r
+{ PRE : T creada.\r
+ POST: T vac¡a.\r
+}\r
+\r
+\r
+BEGIN\r
+\r
+ LSC_vaciar (t.lista);\r
+ t.ordenada:= true;\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Borrar_Cte ( var T: T_TABLA );\r
+{\r
+ PRE : T no vac¡a.\r
+ POST: Se elimin¢ el registro corriente.\r
+ El nuevo registro corriente es el siguiente del borrado, si el borrado\r
+ era el £ltimo, entonces el nuevo corriente es el primero.\r
+}\r
+\r
+BEGIN\r
+\r
+ LSC_borrar_cte ( t.lista );\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Modif_Cte ( var T: T_TABLA ; var R: T_REGISTRO );\r
+{\r
+ PRE : T no vac¡a.\r
+ POST: El contenido del actual corriente fue actualizado con R.\r
+ Si T estaba ordenada y no se modificaron los datos de la clave del\r
+ corriente, entonces T sigue ordenada. Si T estaba ordenada y se\r
+ modificaron los datos de la clave del corriente, entonces si la\r
+ nueva clave rompe el orden de T, T no est m s ordenada.\r
+}\r
+VAR e: T_REGISTRO;\r
+\r
+BEGIN\r
+\r
+ T_TABLA_Elem_Cte (t, e);\r
+\r
+ if Devolver_Clave_Elem( e ) <> Devolver_Clave_Elem( r ) then\r
+ t.ordenada:= false;\r
+\r
+ LSC_modif_cte (t.lista, r);\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Ordenar ( var T: T_TABLA );\r
+{\r
+ PRE : T no vac¡a.\r
+ POST: T se encuentra ordenada por la clave de sus registros.\r
+}\r
+VAR t_aux: T_TABLA;\r
+\r
+ e: T_REGISTRO;\r
+\r
+ error: boolean;\r
+\r
+BEGIN\r
+\r
+ error:= false;\r
+\r
+ T_TABLA_Crear( t_aux);\r
+\r
+ LSC_COPIAR(t.lista, t_aux.lista);\r
+\r
+ T_TABLA_Limpiar(t);\r
+\r
+(* {tengo que mover en corriente al primero porque esta en nulo (0)}\r
+ T_TABLA_Mover_Cte ( t, lsc_primero, error );\r
+Era un bolazo\r
+*)\r
+\r
+ T_TABLA_Elem_cte(t_aux, e);\r
+\r
+ T_TABLA_Insertar (t, e, lsc_primero);\r
+\r
+ T_TABLA_Mover_Cte ( t_aux, lsc_siguiente, error );\r
+\r
+ t.ordenada:= true; {si tiene un solo elemento no veo porque no}\r
+\r
+ while error <> true do begin\r
+\r
+ T_TABLA_Elem_cte(t_aux, e);\r
+\r
+ T_TABLA_Insertar_O (t, e);\r
+\r
+ T_TABLA_Mover_Cte ( t_aux, lsc_siguiente, error );\r
+\r
+ end;\r
+\r
+ t.ordenada:= true;\r
+\r
+END;\r
+\r
+Procedure T_TABLA_Buscar_Clave ( var T: T_TABLA ; C: T_CLAVE; var error :boolean);\r
+{\r
+ PRE : T no vac¡a.\r
+ POST: Si C es una clave que existe en T, entonces el nuevo corriente es el\r
+ registro con clave C y error es falso, sino error es verdadero y\r
+ el corriente es el registro donde termino la busqueda (modificacion\r
+ hecha para facilitar la operacion insertar ordenado).\r
+}\r
+VAR e: T_REGISTRO;\r
+\r
+BEGIN\r
+\r
+ error:= false;\r
+\r
+{ IF not T_TABLA_Vacia(t) then begin\r
+}\r
+ T_TABLA_Mover_Cte ( t, lsc_primero, error );\r
+\r
+ T_TABLA_Elem_cte(t, e);\r
+\r
+ While (e.DNI < c ) AND not error do begin\r
+\r
+ T_TABLA_Mover_Cte ( t, lsc_siguiente, error );\r
+\r
+ T_TABLA_Elem_cte(t, e);\r
+\r
+ END;\r
+\r
+ IF e.dni <> c then error := true;\r
+\r
+{ END\r
+ ELSE error:= true;\r
+}\r
+END;\r
+\r
+PROCEDURE Buscar_por_Rango(var T: T_TABLA; D, H: T_CLAVE; var L: PILAC_Pila);\r
+{\r
+ BUSCA LOS REGISTROS COMPRENDIDOS ENTRE LAS CLAVES D y H\r
+ Y LOS ALMACENA EN LA PILA L.\r
+}\r
+VAR\r
+ error: boolean;\r
+ e: T_REGISTRO;\r
+\r
+BEGIN\r
+ error:= false;\r
+\r
+ T_TABLA_Buscar_Clave(t,d,error);\r
+\r
+{ if error = false then begin}\r
+\r
+ T_TABLA_Elem_cte(t, e);\r
+\r
+ PILAC_poner ( l,e );\r
+\r
+ T_TABLA_Mover_Cte ( t, lsc_siguiente, error );\r
+\r
+ T_TABLA_Elem_cte(t, e);\r
+\r
+\r
+ While (e.DNI <= h ) AND (error = false) do begin\r
+\r
+ PILAC_poner ( l,e );\r
+\r
+ T_TABLA_Mover_Cte ( t, lsc_siguiente, error );\r
+\r
+ T_TABLA_Elem_cte(t, e);\r
+\r
+ END; {WHILE}\r
+\r
+{ END; {IF}\r
+\r
+END;\r
+\r
+END.
\ No newline at end of file
--- /dev/null
+unit tda_gral;\r
+\r
+{ funciones y datos y tipo generales de los TDA de almacenamiento\r
+ Basado en el codigo de la catedra, modificado para que compile.\r
+ Los tipos de datos de los elementos de Persona fueron reemplazados\r
+ por los que se usan en el TP.\r
+}\r
+\r
+\r
+\r
+interface\r
+\r
+\r
+\r
+{ aca se define el famoso tipo_elem }\r
+\r
+type\r
+\r
+ TipoDNI = string[8];\r
+\r
+ Persona = record\r
+\r
+ DNI : TipoDNI;\r
+\r
+ Nombre : string[40];\r
+\r
+{Apellido no es necesario para el TP}\r
+{ Apellido : ShortString; }\r
+\r
+ end;\r
+\r
+\r
+\r
+ Tipo_Clave = TipoDNI;\r
+\r
+ Tipo_Elem = Persona;\r
+\r
+\r
+\r
+{ esta funcion devuelve la clave de un elemento almacenado }\r
+\r
+{ PRE : ninguna }\r
+\r
+{ POST: devuelve la clave de un elemento E }\r
+\r
+function Devolver_Clave_Elem( E: Tipo_Elem): Tipo_Clave;\r
+\r
+\r
+\r
+{ este procedimiento se usa en recorridos e imprime los datos del elemento }\r
+\r
+{ PRE : ninguna }\r
+\r
+{ POST: se imprimieron los datos }\r
+\r
+procedure Procesar_Elem_Recorrido ( var e: Tipo_Elem);\r
+\r
+\r
+\r
+{ compara dos elementos completos para ver si cumplen con el criterio o no }\r
+\r
+FUNCTION Comparar_Elementos( a: Tipo_Elem; b: Tipo_Elem ): boolean;\r
+\r
+\r
+\r
+implementation\r
+\r
+\r
+\r
+{ esta funcion devuelve la clave de un elemento almacenado }\r
+\r
+function Devolver_Clave_Elem( E: Tipo_Elem): Tipo_Clave;\r
+\r
+begin\r
+\r
+ Devolver_Clave_Elem := E.DNI;\r
+\r
+end;\r
+\r
+\r
+\r
+{ este procedimiento se usa en recorridos e imprime los datos del elemento }\r
+\r
+procedure Procesar_Elem_Recorrido ( var e: Tipo_Elem);\r
+\r
+BEGIN\r
+\r
+\r
+\r
+END;\r
+\r
+\r
+\r
+{ compara dos elementos completos para ver si cumplen con el criterio o no }\r
+\r
+FUNCTION Comparar_elementos( a: Tipo_Elem; b: Tipo_Elem ): boolean;\r
+\r
+BEGIN\r
+\r
+ IF a.DNI = b.DNI\r
+\r
+ THEN\r
+\r
+ Comparar_Elementos := true\r
+\r
+ ELSE \r
+\r
+ Comparar_Elementos := false;\r
+\r
+END;\r
+\r
+\r
+\r
+end.\r
+\r
--- /dev/null
+program tp1;\r
+{\r
+ TRABAJO PRACTICO NUMERO 1\r
+ 1er Cuatrimestre 2000\r
+\r
+}\r
+\r
+uses TDA_GRAL, ldoblec, tabla, pila_C, crt;\r
+\r
+Type\r
+ T_registro_entrada = record\r
+ Comando: string[2];\r
+ DNI: string[8];\r
+ Nombre: string[40];\r
+ Movimiento: string[1];\r
+ DNI_hasta: string[8];\r
+ End;\r
+ comando = ( OTRO, INS, IO, ORD, BC, BR, LS, LC, BO, MO, LI);\r
+\r
+\r
+Var mitabla: T_TABLA;\r
+ pila: PILAC_Pila;\r
+ infile: file of T_registro_entrada;\r
+ cmd: comando;\r
+ mov: t_movim;\r
+ o: text;\r
+ r: T_registro_entrada;\r
+ e: t_registro;\r
+ error: boolean;\r
+ aux: string;\r
+\r
+\r
+{------- Aca empieza el programa -------}\r
+\r
+begin\r
+\r
+ WriteLn;\r
+ Writeln('Archivo de Entrada:', ParamStr(1));\r
+ Writeln('Archivo de Salida :', ParamStr(2));\r
+\r
+ Assign(infile, ParamStr(1));\r
+ Reset (infile);\r
+\r
+ Assign(o, ParamStr(2));\r
+ rewrite (o);\r
+\r
+ Writeln(o,'Archivo de Entrada:', ParamStr(1));\r
+ Writeln(o,'Archivo de Salida :', ParamStr(2));\r
+ Writeln(o);\r
+\r
+ T_TABLA_Crear(mitabla);\r
+ PILAC_Inicializar (pila);\r
+\r
+ while not eof(infile) do begin\r
+\r
+ read(infile, r);\r
+\r
+{ r.comando:= UpCase (r.comando);}\r
+\r
+ writeln(o);\r
+ write(o,'>',r.comando);\r
+ write(o,' ',r.dni);\r
+ write(o,' ',r.nombre);\r
+ write(o,' ',r.movimiento);\r
+ write(o,' ',r.dni_hasta);\r
+ writeln(o);\r
+\r
+ e.dni:= r.dni;\r
+ e.nombre:= r.nombre;\r
+\r
+{Estos bloques son para interpretar los strings y ponerlos en un enumerado}\r
+\r
+ IF r.comando = 'IN' then cmd:= INS\r
+ ELSE IF r.comando = 'IO' then cmd:= IO\r
+ ELSE IF r.comando = 'OR' then cmd:= ORD\r
+ ELSE IF r.comando = 'BC' then cmd:= BC\r
+ ELSE IF r.comando = 'BR' then cmd:= BR\r
+ ELSE IF r.comando = 'LS' then cmd:= LS\r
+ ELSE IF r.comando = 'LC' then cmd:= LC\r
+ ELSE IF r.comando = 'BO' then cmd:= BO\r
+ ELSE IF r.comando = 'MO' then cmd:= MO\r
+ ELSE IF r.comando = 'LI' then cmd:= LI;\r
+\r
+ IF r.movimiento= 'P' then mov:=lsc_primero\r
+ ELSE IF r.movimiento= 'A' then mov:=lsc_anterior\r
+ ELSE IF r.movimiento= 'S' then mov:=lsc_siguiente\r
+ ELSE IF r.movimiento= 'U' then mov:=lsc_ultimo;\r
+\r
+ CASE cmd of\r
+\r
+ INS: begin\r
+\r
+ T_TABLA_Insertar(mitabla, e, mov)\r
+\r
+ end;\r
+\r
+ IO: begin\r
+\r
+ T_TABLA_Insertar_O(mitabla, e)\r
+\r
+ end;\r
+\r
+ ORD: begin\r
+\r
+ T_TABLA_Ordenar(mitabla)\r
+\r
+ end;\r
+\r
+ BC: begin\r
+\r
+ T_TABLA_Buscar_Clave (mitabla, r.dni, error );\r
+\r
+ IF Error then\r
+ writeln(o,'Error buscando la clave: ',r.dni)\r
+ Else\r
+ begin\r
+\r
+ T_TABLA_Elem_Cte (mitabla, e);\r
+\r
+ writeln('Encontrado: ', e.nombre);\r
+\r
+ end;\r
+\r
+ end;\r
+\r
+ BR: begin\r
+\r
+ Buscar_por_Rango(mitabla, r.dni, r.dni_hasta, pila);\r
+\r
+ Writeln(o,'RESULTADOS DE LA BUSQUEDA:');\r
+\r
+ Writeln(o,'--------------------------');\r
+\r
+ while not PILAC_vacio(pila) do begin\r
+\r
+ PILAC_sacar(pila, e);\r
+\r
+ writeln(o,' ',e.dni,' - ', e.nombre);\r
+\r
+ end;\r
+\r
+ Writeln(o,'----- FIN BUSQUEDA ------');\r
+\r
+ end;\r
+\r
+ LS: begin\r
+\r
+ If NOT T_TABLA_Vacia (mitabla) then begin\r
+\r
+ T_TABLA_Mover_Cte (mitabla, lsc_primero, error);\r
+\r
+ error:= false;\r
+\r
+ while NOT error do begin\r
+\r
+ T_TABLA_Elem_Cte (mitabla, e);\r
+\r
+ writeln(o,' ',e.dni,' - ', e.nombre);\r
+\r
+ T_TABLA_Mover_Cte (mitabla, lsc_siguiente, error);\r
+\r
+ end;\r
+ end\r
+\r
+ Else\r
+\r
+ Writeln(o, 'TABLA VACIA');\r
+\r
+ end;\r
+\r
+ LC: begin\r
+\r
+ T_TABLA_Elem_Cte (mitabla, e);\r
+\r
+ writeln(o,' ',e.dni,' - ', e.nombre);\r
+\r
+ end;\r
+\r
+ BO: T_TABLA_Borrar_Cte ( mitabla );\r
+\r
+ MO: T_TABLA_Modif_Cte (mitabla, e);\r
+\r
+ LI: T_TABLA_Limpiar (mitabla);\r
+\r
+ ELSE\r
+ writeln(o,' ERROR. Comando desconocido :', r.comando );\r
+\r
+ end; {case}\r
+\r
+ end; {while}\r
+\r
+ close(o);\r
+\r
+end.\r
+\r
projects / z.facultad / 75.41 / material.git / commitdiff