República Bolivariana de Venezuela Ministerio del Poder Popular para la Defensa Universidad Nacional Experimental de la Fuerza Armada Nacional Bolivariana Núcleo: Anzoátegui – San Tome
PROGRAMACIÓN ___ _______ ____
Prof.
Integrantes:
Lesmary Lara
Kairolys Reina Franklin Mendoza
San Tome Ju nio 2013
Índ ic e_______________________________________ _____________________
Introducción_______________________________________________________ ............. 3 Pilas_________________________________________________________.................. .... 4 Colas_____________________________________________________________ ........... 6 Listas_____________________________________________________________ ........... 7 Listas enlazadas circulares simples ........................................................................................
10
Listas enlazadas doblemente circulares ................................................................................. 11 Aplicaciones ................................................................................................................................
11
Lenguajes soportados ...............................................................................................................
12
Árboles___________________________________________________________ .......... 12 Sistema de Archivos________________________________________________ ............ ............ 14 Operaciones con Archivos: .......................................................................................................
15
Archivos Aleatorios_________________________________________________ ............ ............ 20 Ejercicios_________________________________________________________ ........... 24 Conclusión________________________________________________________........... 2 5 Anexos________________________________________________________ ___........... 26
Introducción_______________________________________________________ Los datos están formados por una estructura que se caracteriza por el hecho de que con un nombre se hace referencia a un grupo o espacio de memoria. A esto se le llama estructura de datos. En este trabajo se detalla las diferentes formas en la que se puede hacer dicha estructuras por que son un aspecto muy importante en la computación. Se definirán los conceptos de pilas y colas y su uso y forma de operar de igual manera listas y por última arboles. Pasando por los Sistemas de Archivos, Grafos y Aleatorios.
3
Pilas_________________________________________________________
Las pilas son estructuras de datos que tienes dos operaciones básicas: push (para insertar un elemento) y pop (para extraer un elemento). Su característica fundamental es que al extraer se obtiene siempre el último elemento que acaba de insertarse. Por esta razón también se conocen como estructuras de datos LIFO (del inglés Last In First Out). Una posible implementación mediante listas enlazadas sería insertando y extrayendo siempre por el principio de la lista. Gracias a las pilas es posible el uso de la recursividad (lo veremos en detalle en el tema siguiente). La variable que llama al mismo procedimiento en el q está, habrá que guardarla así como el resto de variables de la nueva llamada, para a la vuelta de la recursividad ir sacándolas, esto es posible a la implementación de pilas.
Las pilas se utilizan en muchas aplicaciones que utilizamos con frecuencia. Por ejemplo, la gestión de ventanas en Windows (cuando cerramos una ventana siempre recuperamos la que teníamos detrás). Otro ejemplo es la evaluación general de cualquier expresión matemática para evitar tener que calcular el número de variables temporales que hacen falta. Por ejemplo: es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura. Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado. En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés).
4
La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS. Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo. Las pilas suelen emplearse en los siguientes contextos: Evaluación de expresiones en notación postfija (notación polaca inversa). Reconocedores sintácticos de lenguajes independientes del contexto Implementación de recursividad Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las implementaciones modernas de las pilas se suelen añadir más de uso habitual. Crear: se crea la pila vacía. (Constructor) Tamaño: regresa el número de elementos de la pila. (Size) Apilar: se añade un elemento a la pila. (Push) Desapilar: se elimina el elemento frontal de la pila. (Pop) Cima: devuelve el elemento que esta en la cima de la pila. (Top o peek) Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty). Implementación: Un requisito típico de almacenamiento de una pila de n elementos es O(n). El requisito típico de tiempo de O (1) las operaciones también son fáciles de satisfacer con un array o con listas enlazadas simples. La biblioteca de plantillas de C++ estándar proporciona una "pila" clase templated que se limita a sólo apilar/desapilar operaciones. Java contiene una biblioteca de la clase Pila que es una especialización de Vector. 5
Esto podría ser considerado como un defecto, porque el diseño heredado get () de Vector método LIFO ignora la limitación de la Pila. Estos son ejemplos sencillos de una pila con las operaciones descritas anteriormente (pero no hay comprobación de errores).
Colas_____________________________________________________________
Las colas también son llamadas FIFO (First In First Out), que quiere decir “el primero que entra es el primero que sale”.
Colas simples: Se inserta por un sitio y se saca por otro, en el caso de la cola simple se inserta por el final y se saca por el principio. Para gestionar este tipo de cola hay que recordar siempre cual es el siguiente elemento que se va a leer y cual es el último elemento que se ha introducido. Colas circulares: En las colas circulares se considera que después del último elemento se accede de nuevo al primero. De esta forma se reutilizan las posiciones extraídas, el final de la cola es a su vez el principio, creándose un circuito cerrado. Lo que se ha hecho es insertar (5), sacar (1), e insertar (8). Se sabrá que una tabla está llena cuando “rear” y “front” estén en una posición de
diferencia. El teclado de ordenador se comporta exactamente como una cola circular. Para implementar las colas circulares mediante listas enlazadas se pone en el tipo T_Lista los punteros front y rear.
6
Colas con prioridad:Las colas con prioridad se implementan mediante listas o arrays ordenados. No nos interesa en este caso que salgan en el orden de entrada sino con una prioridad que le asignemos. Puede darse el caso que existan varios elementos con la misma prioridad, en este caso saldrá primero aquel que primero llego (FIFO).
Listas_____________________________________________________________
Matemáticamente, una lista es una sucesión finita de cero, uno o más elementos del mismo tipo. Desde el punto de vista de las estructuras de datos, una lista es un conjunto finito de elementos, en el que para acceder a uno de ellos hay que pasar por todos los situados antes que él. Una lista es, por lo tanto, una estructura de datos secuencial. Ejemplos de listas utilizadas cotidianamente pueden ser: la lista de personas en la cola para visitar a un médico, la secuencia de pasos de una receta de cocina, la lista de jugadores de un equipo de fútbol,... Las listas son estructuras de datos particularmente flexibles ya que pueden ir creciendo o decreciendo según se necesite y pueden accederse, insertarse o eliminarse elementos en cualquier posición dentro de la lista. En un programa se puede trabajar con una lista de datos a través de una variable de tipo array, es decir, una estructura de datos estática, pero es preferible implementar la lista mediante una estructura de datos dinámica para aprovechar y emplear de una forma más flexible y óptima la memoria. Como ya se adelantó en el capítulo anterior, para llevar esto a cabo hay que utilizar variables de tipo apuntador o puntero. En e ste capítulo se tratará el tema de las listas no a nivel teórico, sino fundamentalmente, desde el punto de vista de su implementación como una estructura de datos dinámica dentro de un programa. 7
Para construir una lista dinámica de datos se han de definir los elementos de la lista como datos de tipo record con dos clases de campos: una serie de campos que almacenan información y otra serie de campos de tipo apuntador o puntero. Al menos se necesita uno de estos campos para que almacene la posición de memoria del siguiente elemento de la lista. Por lo tanto, los campos puntero de los elementos de las listas utilizados en general en los programas almacenarán direcciones de memoria de ese mismo tipo de datos (apuntarán a otros datos que son elementos de la propia lista). El acceso a un elemento de una lista dinámica sería comparable a la búsqueda de un tesoro escondido en la que, en cada pista que se halla, se dice donde encontrar la siguiente. Un ejemplo de definición de un elemento de una lista simple sería el siguiente: type puntero = ^elemento; Elemento = record Dato: integer; sig : puntero end; var p : puntero; Se denomina lista dinámica simple porque sus elementos sólo necesitan un campo de tipo puntero. En este caso, los elementos de la lista simple son de tipo record con dos campos: En uno de ellos se almacena un número entero y en el otro la dirección de memoria del siguiente elemento en la lista. Hay que hacer constar que estas declaraciones no dan lugar a un error de compilación al utilizar el identificador elemento en la definición de puntero sin haberlo previamente declarado: es una excepción a la regla. Ya que, en todo caso, ¿qué habría que Definir primero: elemento ó puntero? El compilador decide, en este caso, que se debe declarar primero el tipo de dato puntero. 8
El siguiente programa utiliza la declaración de tipos anterior para generar una lista y posteriormente visualizar los valores que se acaban de introducir. program lista_1; {Crea una lista en el orden contrario a su introduccion } Listas dinámicas 143 {Primero introduce los datos y luego los visualiza } type puntero = ^elemento; Elemento = record Dato: integer; Sig. : puntero end; var p, q : puntero; A: integer; begin p:=nil; { Almacena en p la constante nil } readln(a); { Asigna un valor a la variable entera a } while a<>0 do begin new(q); { Reserva espacio para una variable dinamica q^ } { y almacena en q su direccion de memoria } q^.dato:=a; { Almacena el valor de a en el campo dato } q^.sig:=p; { Almacena en sig la misma direccion que en p } 9
p:=q; { Y ahora en p la misma direccion que en q } readln(a) { Asigna otro valor a la variable entera a } end; { Cuando se cumple que a=0 el bucle dejar de ejecutarse } writeln('Valores de la lista : '); { El siguiente bucle visualiza por pantalla el valor almacenado en el campo dato de todos los elementos de la lista. Acaba cuando la variable q almacena la constante nil: esta indica el final de la lista } while q<>nil do begin writeln(q^.dato); q:=q^.sig end end. L i s t a s e n l a z ad a s c i r c u l a r es s i m p l e s
Cada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto que el siguiente nodo del último apunta al primero. Como en una lista enlazada simple, los nuevos nodos pueden ser solo eficientemente insertados después de uno que ya tengamos referenciado. Por esta razón, es usual quedarse con una referencia solamente al último elemento en una lista enlazada circular simple, esto nos permite rápidas inserciones al principio, y también permite accesos al primer nodo desde el puntero del último nodo. 1 10
L i s t a s e n l a z ad a s d o b l e m e n t e c i r c u l a r es
En una lista enlazada doblemente circular, cada nodo tiene dos enlaces, similares a los de la lista doblemente enlazada, excepto que el enlace anterior del primer nodo apunta al último y el enlace siguiente del último nodo, apunta al primero. Como en una lista doblemente enlazada, las inserciones y eliminaciones pueden ser hechas desde cualquier punto con acceso a algún nodo cercano. Aunque estructuralmente una lista circular doblemente enlazada no tiene ni principio ni fin, un puntero de acceso externo puede establecer el nodo apuntado que está en la cabeza o al nodo cola, y así mantener el orden tan bien como en una lista doblemente enlazada.
Aplicaciones
Las listas enlazadas son usadas como módulos para otras muchas estructuras de datos, tales como pilas, colas y sus variaciones. El campo de datos de un nodo puede ser otra lista enlazada. Mediante este mecanismo, podemos construir muchas estructuras de datos enlazadas con listas; esta practica tiene su origen en el lenguaje de programación Lisp, donde las listas enlazadas son una estructura de datos primaria (aunque no la única), y ahora es una característica común en el estilo de programación funcional. A veces, las listas enlazadas son usadas para implementar vectores asociativos, y estas en el contexto de las llamadas listas asociativas. Hay pocas ventajas en este uso de las listas enlazadas; hay mejores formas de implementar éstas estructuras, por ejemplo con árboles binarios de búsqueda equilibrados. Sin embargo, a veces una lista enlazada es dinámicamente creada fuera de un subconjunto propio de nodos semejante a un árbol, y son usadas más eficientemente para recorrer ésta serie de datos.
11
Lenguajes soportados
Muchos lenguajes de programación tales como Lisp y Scheme tienen listas enlazadas simples ya construidas. En muchos lenguajes de programación, estas listas están construidas por nodos, cada uno llamado cons o celda cons. Las celdas cons tienen dos campos: el car, una referencia del dato al nodo, y el cdr, una referencia al siguiente nodo. Aunque las celdas cons pueden ser usadas para construir otras estructuras de datos, este es su principal objetivo. En lenguajes que soportan tipos abstractos de datos o plantillas, las listas enlazadas ADTs o plantillas están disponibles para construir listas enlazadas. En otros lenguajes, las listas enlazadas son típicamente construidas usando referencias junto con el tipo de dato record. En la sección de implementaciones hay un ejemplo completo en C y en Maude
Árboles___________________________________________________________
Un árbol es una estructura de datos dinámica ( las estructuras del árbol pueden cambiar durante la ejecución del programa ) no lineal ( puesto que a cada elemento del árbol puede seguirle varios elementos ) y homogénea en el que cada elemento puede tener varios elementos posteriores y solamente un elemento anterior. Es una estructura jerárquica aplicada sobre una colección de elementos u objetos llamados nodos, de los cuales uno es conocido como raíz , además se crea una relación de parentesco entre los nodos dando lugar a términos como padre, hijo, hermano, antecesor, sucesor, ancestro, etc. Un árbol es una estructura que está compuesta por un dato y varios árboles. Dado un nodo cualquiera de la estructura, podemos considerarlo como una estructura independiente, es decir un nodo cualquiera puede ser considerado como la raíz de una árbol completo. 12
En relación con otros nodos: Nodo Padre: Nodo que contiene un puntero al nodo actual. En un árbol un nodo solo puede tener un nodo padre.. X es padre de Y sí y solo sí el nodo X apunta a Y, también se dice que X es antecesor de Y. En la figura B es padre de E y F. Nodo Hijo: Cualquiera de los nodos apuntados por uno de los nodos del aŕbol. Un nodo puede tener varios hijos.. X es hijo de Y, sí y solo sí el nodo X es apuntado por Y. Tambien se dice que X es descenciente directo de Y. En la figura : E es hijo de B. Hermano: Dos nodos serán hermanos si son descencientes directos de un mismo nodo. En la figura Ey F son hermanos. En cuanto a la posición dentro del árbol: Nodo Raíz : Es el único nodo del árbol que no tiene padre. Este es el nodo que usaremos para referirnos al árbol. En la figura A es el nodo raíz. Nodo Hoja: Nodo que no tiene hijos. Se llama hoja o terminal a aquellos nodos que no tienen ramificaciones ( hijos ). En la figura .. N es un nodo hoja. Nodo Interior : Es un nodo que no es raíz ni hoja. En la figura .. D es un nodo interior. Orden: Es el número potencial de hijos que puede tener cada elemento de árbol. De este modo, diremos que un árbol en el que cada nodo puede apuntar a otros dos es de orden dos, si puede apuntar a tres será de orden tres, etc. Podríamos decir que nuestro árbol de ejemplo es de orden tres. Grado: El número de hijos que tiene el elemento con más hijos dentro del árbol. En el árbol del ejemplo, el grado es tres, ya que tanto A como D tienen tres hijos, y no existen elementos con más de tres hijos.
13
Nivel: Se define para cada elemento del árbol como la distancia a la raíz, medida en nodos. El nivel de la raíz es cero, el de sus hijos uno y asi sucesivamente. En el ejemplo, el nodo D tiene nivel 1, el nodo G tiene nivel 2 y el nodo N nivel 3. Rama: Es el camino desde el nodo raíz a una hoja. En el ejemplo A-B-E-K y A-B-F son ramas. Altura: La altura de un árbol se define como el nivel del nodo de mayor nivel. Como cada nodo de un árbol puede considerarse a su vez como la raíz de un árbol, tambien podemos hablar de altura de ramas, el máximo número de nodos que hay que recorrer para llegar de la raíz a una de las hojas. El árbol de la Figura tiene altura 3, la rama B tiene altura 2, la rama G tiene altura 1 y la N cero. Peso: Es el número de nodos del árbol sin contar la raíz. Camino: Es una consecuencia de nodos, en el que dos nodos consecutivos cualesquiera son padre e hijo. En el ejemplo A-D-H y A-C-G-M son caminos. Longitud de camino: Es el número de arcos que deben ser recorridos para llegar desde la raíz al nodo X. Por definición la raíz tiene longitud de camino 1, y sus descendientes directos longitud de camino 2 y así sucesivamente. En nuestro árbol de ejemplo G tiene longitud de camino 3 y N tiene longitud de camino 4.
Sistem a d e A rch ivo s________________________________________________
Un sistema de archivos es un conjunto de tipo de datos abstractos que son implementados para el almacenamiento, la organización jerárquica, la manipulación, el acceso, el direccionamiento y la recuperación de datos. Los sistemas de archivos comparten mucho en común con la tecnología de las bases de datos.
14
Operaciones con Archivos: Existen muchas operaciones asociadas a archivos, las más elementales son: 1.- Creación de Archivo.- En este proceso se pretende solamente crear un archivo nuevo en disco con su nombre tipo y especialidad de almacenamiento de datos apropiado. 2.- Apertura de Archivos.- En este caso se pretende abrir un archivo ya existente en disco para procesarlo ya sea para cargar o grabar estructuras en sus registros o leer algún registro en especial para mandarlo a una variable de cualquier tipo. No confundir creación con apertura, creación es un proceso que solo se ejecuta una sola vez en la vida de un archivo, mientras que apertura, siempre se esta realizando por los programas especializados en algún proceso. 3.- Cierre de archivos: Es la operación mas importante en cualquier programa que maneje archivos, o se cierra el archivo como ultima instrucción del programa o se vera el anuncio ABORT, RETRY, FAIL. 98, /s, scandisk. 4.- Altas en archivo.- En este proceso se captura una estructura en memoria con sus datos pertinentes y después se graba la estructura al archivo en disco. 5.- Lectura de archivo.- En este proceso se abre el archivo, se manda el registro de disco a una estructura en memoria para su procesamiento. 6.- Consulta de archivos: En este proceso se pretende desplegar todos los registros del archivo en disco a la pantalla. 7.- Búsqueda en archivos: Una de las operaciones mas comunes consiste en que el usuario pide toda la información de algún renglón en disco proporcionando la información de algún campo generalmente el campo clave de la estructura. 8.- Filtros.- En este proceso el usuario esta interesado en algún conjunto de renglones con características comunes (condición), por ejemplo todos los alumnos de “sistemas” o todos los empleados que ganen mas de $500.00 pesos, o todos los clientes que sean de “tijuana”, etc.
15
9.- Modificaciones de registros o archivos: Problema muy común, donde los datos originales ya grabados se tienen que cambiar o actualizar, por ejemplo el nombre no era “juan” es “juana”, o la calificación no es 100 es 20, etc. 10.- Bajas de registros: también muy común este proceso, por ejemplo el alumno ya egreso, el cliente huyo, etc. Archivos Secuenciales: Los archivos secuenciales se denominan de esta manera por que la forma de escribir y leer los datos en un archivo es, desde el principio hasta el fin del archivo, es decir, si yo quisiera acceder a un determinado dato del archivo y este dato se encuentra en la mitad del archivo, para llegar a ese dato necesito pasar por todos los demás datos, de forma secuencial. El archivo finaliza con una marca de fin de archivo (eof). Declaración de un archivo Para declarar un archivo primero se declara una variable tipo text de la siguiente forma: VAR VarArchivo : Text; Una vez declarada la variable se asigna al nombre de algún archivo: ASSIGN (VarArchivo, NombreArchivo); Donde NombreArchivo es una cadena de caracteres que contiene el nombre del archivo, la unidad de disco donde se encuentra y el directorio. Por ejemplo: ASSIGN (VarArchivo, 'C:\DOS\PRUEBA.TXT');
16
Abrir archivos Existen tres formas de abrir un archivo:
Escribir datos en un archivo Para escribir datos a un archivo se utilizan las instrucciones Write y WriteLn, como si se quisiera escribir a la pantalla, con la diferencia de que se especificará la variable de archivo ya declarada. Ejemplo: WriteLn(VarArchivo, 'Prueba de archivos'); Esta sentencia grabaría el texto 'Prueba de archivos' en el archivo asignado a VarArchivo. Leer datos de un archivo Para leer los datos de un archivo de acceso secuencial se utilizan las instrucciones Read y ReadLn. La instrucción Read lee uno o varios datos del archivo abierto y deja el puntero en el mismo renglón en el cual leyó los datos, en cambio ReadLn lee los datos y mueve el puntero al siguiente renglón. Fin del archivo Normalmente los archivos de este tipo se leen renglón por renglón hasta llegar al final del mismo. Cuando se conoce de antemano el tamaño del archivo es posible utilizar un ciclo FOR, pero es más seguro utilizar la función EOF la cual es verdadera después de que el programa lee la última línea de un archivo de acceso secuencial.La sintaxis de la función EOF es: EOF (VaribleArchivo);
17
Es común realizar la verificación de la función con un ciclo WHILE como en el ejemplo siguiente: WHILE NOT EOF(Archivo) DO BEGIN ReadLn(Archivo, Datos); WriteLn(Datos); END; Cerrar archivos: Para asegurar que toda la información se grabe en el disco correctamente es necesario cerrar el archivo antes de que se termine la ejecución del programa, de lo contrario se corre el riego de que la última información que se haya accesado no se grabe en su totalidad.La instrucción para cerrar un archivo es Close, y su sintaxis es:Close (VaribleArchivo) Función Eoln: La función Eoln sirve para verificar si el puntero ha llegado al final de la línea. Regresa el valor verdadero si se encuentra al final. Comúnmente se utiliza en las lecturas carácter por carácter. Agregar datos a un archivo de texto: Para añadir datos a un archivo de texto son necesarios los siguientes pasos: Asignar un archivo a una variable con Assign Agregar los datos con el procedimiento Append Escribir los datos Cerrar el archivo A continuación se ilustra un ejemplo de un programa que agrega una línea a un archivo de texto:
18
PROGRAM Archivo; VAR Texto : TEXT; BEGIN Assign (Texto, 'PRUEBA.DAT'); ppend(Texto); WriteLn(Texto, 'Agregando una linea al archivo PRUEBA.DAT'); Close (Texto) END. Archivos Secuenciales Indexados: Estos archivos mantienen las características básicas de los archivos secuenciales: los registros se organizan en secuencia basada en un campo clave. Definición de Índice: Un índice en informática es como el índice de un libro donde tenemos los capítulos del libro y la página donde empieza cada capítulo. Un índice es una estructura de datos que permite recuperar las filas de una tabla de forma más rápida además de proporcionar una ordenación distinta a la natural de la tabla. Un índice se define sobre una columna o sobre un grupo de columnas, y las filas se ordenarán según los valores contenidos en esas columnas. Por ejemplo, si definimos un índice sobre la columna población de la tabla de clientes, el índice permitirá recuperar los clientes ordenados por orden alfabético de población. Ventajas de los archivos secuenciales indexados • Rápido acceso. • El sistema de gestión de archivos se encarga de relacionar la posición de cada
registro con su contenido mediante la tabla de índices. Desventajas
19
• Desaprovechamiento del espacio por quedar huecos intermedio cada vez que
se actualiza el archivo.
• Se necesita espacio adicional para el área de índices.
Características de los Archivos Secuenciales Indexados: • Los registros se organizan en una secuencia basada en un campo clave. • Se incluye una tabla de índices que propor ciona una capacidad de búsqueda
para llegar a las proximidades de un registro deseado mediante la clave.
Ar ch ivo s A leatori os _________________________________________________
A diferencia de los archivos secuenciales, los archivos aleatorios almacenan datos en forma de registros. Como habíamos dicho en la unidad anterior para leer datos de un archivo secuencial había que leer todo el archivo, es decir que no podíamos leer por ejemplo los datos que estuviesen en la línea 35 del mismo sin antes pasar por todos los datos anteriores, por eso su nombre de archivo secuencial. En cambio los archivos aleatorios, también llamados archivos directos, almacenan los datos con una estructura diferente. Los datos se guardan en registros mediante una estructura definida de tipo Type (estructura definida por nosotros) también llamada UDT. Por ejemplo si tuviésemos 25 registros, cada uno con datos (apellido, e-mail, teléfono, etc.), y quisiera acceder al registro 17, puedo leer los datos del registro 17 sin tener que leer los 16 registros anteriores, ganando con ello más velocidad y teniendo una estructura de datos definida.
20
Declaración de un archivo Para declarar un archivo de acceso directo se realiza con las palabras reservadas FILE OF, su sintaxis es la siguiente: VariableArchivo : FILE OF TipoElementos; Esta declaración se realiza en la sección correspondiente a la declaración de las variables. Ejemplo: PROGRAM Archivo_Tipeado; VAR Archivo : FILE OF Integer; BEGIN END. Normalmente no se desea crear archivos que puedan almacenar un solo tipo de datos ya que se requerirían varios archivos, por ejemplo para alguna base de datos: uno para los nombres, otro para apellidos, otro para la edad, etc. Para evitar este inconveniente es posible usar registros del tipo RECORD, que permiten grabar en un solo registro un grupo de datos que pueden ser de diferentes tipos, uno de tipo INTEGER, uno de tipo STRING, etc. Los registros del tipo record deben ser declarados antes de las variables en una sección llamada TYPE con el siguiente formato:
21
La sección TYPE se escribe antes de la declaración de las variables. Como ejemplo, si se quiere crear un archivo el que se guarden el nombre, domicilio, edad y estado civil de un grupo de personas, el primer paso a realizar es crear un registro que contenga todos estos campos: TYPE Datos = RECORD Nombre : String[40]; Domicilio : String[60]; Edad : Integer; EdoCivil : String[10]; END; El siguiente paso es declarar un archivo del tipo Datos así como una variable del mismo tipo de los que se utilizarán en el archivo: VAR Archivo: FILE OF Datos; Persona : Datos; Asignación de un archivo : Aún cuando se tenga declarado el archivo no es posible grabar nada en él si no se le asigna un nombre real para guardarlo en el disco. El proceso de dicha asignación es el mismo que para los archivos de texto: Assign (Archivo, 'Nombre.ext'); Nombre.txt puede ser una constante, una variable o estar escrita directamente en el programa. Naturalmente debe cumplir con todas las reglas para nombrar un archivo.
Abrir Archivos: Una vez declarado un archivo ya es posible abrirlo. En caso de querer abrir un archivo nuevo se utiliza la instrucción Rewrite, o si el archivo ya existe en el disco se abre con el procedimiento Reset. 22
No existe ninguna diferencia entre la apertura de un archivo de acceso directo para su lectura o para su escritura. Si al utilizar el procedimiento Rewrite el archivo asignado ya existía se eliminará del disco y se creará uno nuevo, por lo mismo se debe tener cuidado al momento de abrir estos archivos.
Posicionamiento en el interior de un archivo: Cada uno de los registros de un archivo esta referenciado por un número específico comenzando desde el registro 0 y aumentando de 1 en 1. La función FilePos devuelve el número de registro actual, su sintaxis es: FilePos (VariableArchivo) VariableArchivo es la variable a la cual se asignó un nombre de archivo en el disco. Para moverse a un registro determinado se utiliza la función Seek, con la siguiente sintaxis: Seek (VariableArchivo, NumRegistro); Para moverse al final del archivo para agregar un nuevo registro se utiliza este mismo comando con el parametro NumRegistro como sigue: Seek (VariableArchivo, FileSize(VariableArchivo)); Cuando se avanza en un archivo registro por registro se utiliza la función EOF para determinar si ya se llegó al final del archivo.
Lectura y escritura de archivos: Para la lectura y escritura en un archivo de acceso directo únicamente se utilizan los procedimientos Read y Write. Después de cada operación de lectura o escritura el puntero se posiciona en el siguiente registro.
Cerrar un archivo: Para cerrar los archivos abiertos se procede igual que en uno de acceso secuencial, utilizando el procedimiento close: Close (VariableArchivo); 23
Ejercic ios _________________________________________________________
24
Conclusión________________________________________________________ La clase de estructura de datos me dejo mucho, desde la programada, lo cual ya mejore un poco más, hasta la lógica de entender y ver las cosas de otra manera. Todo esto que acabo de explicar es un repaso de mi clase estructura de datos y simplemente puedo decir que si pudiera volverla a tomar, tenlo por seguro que volveré a decir esto tantas veces sea un arte programar. END OF FILE; EXIT; En cierto modo y en la búsqueda de la verdad, de la lógica y de la razón hemos analizado profundamente los aspectos técnicos acerca de las diferentes estructuras dinámicas y no dinámicas que se encuentran en el lenguaje, centrándonos especialmente y con particular énfasis en las funciones todas ellas muy importantes para la programación estructurada, las colas ,las pilas herramientas indispensables para el ahorro del tiempo a nosotros los programadores solo la tecnología futura y los nuevos avances tecnológicos nos darán la luz y nos enseñaran el camino por el cual debe pasar la humanidad llevada de la mano por la informática.
25
Anexos___________________________________________________________ Push en una Pila Vacía
Movimientos de Pilas y Colas
Añadiendo Elementos en una Cola Vacía
Grafos
Listas
Arboles
26
