Está en la página 1de 17

UNIVERSIDAD INCA GARCILASO DE LA VEGA FACULTAD DE INGENIERIA DE SISTEMAS, COMPUTO Y TELECOMUNICACIONES

ASIGNATURA TEMA PROFESOR ALUMNO CODIGO FECHA CICLO TURNO SEMESTRE

Estructura de Informacin Filas Secuenciales Carlos A. Ruiz De La Cruz Melo

2010-II

1.

OBJETIVOS

Que el estudiante: Aplique en los algoritmos los conceptos bsicos de este TAD, aprendiendo a utilizar de forma adecuada y eficiente la notacin y la semntica de sus operaciones o acciones elementales a las cuales llamaremos primitivas de acceso. Implemente los algoritmos en C++, poniendo especial nfasis en un tipo de archivo denominado archivos binarios.

2.

INTRODUCCION TEORICA

Las estructuras de datos se dividen en dos grupos Estructuras de datos lineales Filas Secunciales. Arreglos (Vectores, bsqueda y ordenamiento) Listas enlazadas (Simples, doble, circular) Pilas Colas

Estructuras de datos no lineales rboles ( General, binario, balanceado, B, B+) Grafos. Fila Secuencial La Fila secuencial es una estructura de datos lineal usada principalmente para almacenamiento secundario(almacenamiento en disco duro, disquete, cinta, usb). Una Fila secuencial puede almacenar tipos de datos simples y estructurados(TAD). Caractersticas de una fila secuencial Para acceder a un elemento de la fila secuencial es preciso recorrer los elementos anteriores a el. La fila es secuencial uno despus de otro. Despus del ultimo elemento se encuentra la marca de fin de fila secuencial. Existe al final una marca de fin.

Primitivas bsicas Inicio(F) Leer( F, V) Escribir(F, V) Ultimo( F) Cerrar(F) Posiciona la fila F antes del primer elemento Lee el elemento de la fila F en una posicin y lo almacena en la variable V luego avanza una posicin Escribe el valor de V en la fila F siempre en la ultima posicin, luego avanza una posicin Primitiva de la estructura que retorna verdadero si encuentra la marca de fin de la fila y falso en otro caso. Cierra la fila secuencial

Implementacin de las Filas secuenciales La forma clsica de implementar las filas secuenciales es a travs del empleo de archivos los cuales son estructuras de datos en memoria secundaria para almacenar los datos en forma permanente. Archivo Se supone que las entradas y salidas (E/S) de informacin se producen hacia/desde archivos o ficheros ("files"). En C/C++ este es un concepto muy genrico, dado que un archivo puede ser un fichero en disco; una impresora; una cinta magntica; una coleccin de fichas perforadas; una consola, o un teclado. Es decir, desde el punto de vista del programa, el concepto de archivo puede entenderse como dispositivo externo hacia/desde el que puede fluir informacin. Es evidente que no todos los archivos soportan las mismas operaciones. Por ejemplo, una cinta magntica soporta acceso secuencial, mientras que un disco magntico soporta E/S aleatoria. Una impresora solo soporta operaciones de salida (desde el programa que imprime) mientras que un micrfono solo proporciona entradas (hacia el programa que recibe la seal). Tipos de archivos Archivos Secuenciales.- En este caso los datos se almacenan en forma consecutiva y no es posible leer ningn registro directamente, es decir para leer el registro n se deber recorrer o accesar los n-1 registros anteriores. Archivos Directos o Random.- Para este caso si se puede acceder o leer un rengln n cualquiera.

Flujo

Las operaciones de E/S de C y C++ se conceptualizan como corrientes de datos que entran y salen del programa hacia/desde distintos tipos de archivos (como hemos visto, dispositivos que pueden incluir teclado, consola, discos, cintas, Etc.) Aunque cada dispositivo es diferente, el programa utiliza un solo concepto de corriente de datos, denominado flujo, el cual se aplica a los diferentes sistemas de E/S de C y C++:

Sistema de E/S definido por ANSI C/C++ Sistema de E/S tipo UNIX Sistema de E/S de bajo nivel

Tratar todos los sistemas de E/S seria demasiado largo para esta gua, as que solo trataremos la implementacin de las filas secuenciales a travs del sistema de E/S de C++ o mas conocidos como flujos streams dando a conocer las caractersticas y funciones mas importantes y comnmente usadas

Almacenamiento en archivos Modo Texto: en este caso los datos son almacenados usando Ascii y por tanto son plenamente visibles usando cualquier editor.

Modo Binario: en este caso los datos son almacenados en notacin hexadecimal y por tanto se ocupa un editor binario para reconocerlos, sin embargo un archivo binario es mas compacto que un archivo texto. Un archivo binario almacena datos, todos de un mismo tamao y pueden ser simples como datos compuestos(TAD). Cuando almacenamos datos compuesto hablamos de registros en los cuales se aplican dos conceptos:

Campo.- un campo es un tem o elemento de datos elementales, caracterizado por su tamao o longitud y su tipo de datos (cadena, entero, lgico, etc) Registro.- un registro es una coleccin de campos lgicamente relacionados que se almacenan en un archivo en disco en forma de renglones consecutivos.

Ejemplo 1: Archivo de alumnos

3 campos

CODIGO 0980034 0970035 0781200 0891233

NOMBRE Carlos M. Rojas Sanchez Maria Trujillo Trejo Elena Alvarez Mattos Juan Ricra Gomez

NOTA 10 12 14 11

4 registros

DISCO

Cuando almacenamos registros, estos tienen el mismo tamao, constan del mismo numero de campos de tamao fijo en un orden particular. Como se conocen la longitud y la posicin de cada campo, solamente los valores de los campos se necesitan almacenarse; el nombre del campo y longitud de cada campo son atributos de la estructura de archivos. Un campo particular, generalmente el primero de cada registro se conoce como el campo clave. El campo clave identifica unvocamente al registro. as, los valores de la clave para registros diferentes son siempre diferentes. Los archivos secuenciales son tpicamente utilizados en aplicaciones de proceso de lotes Y son ptimos para dichas aplicaciones si se procesan todos los registros. La organizacin secuencias de archivos es la nica que es fcil de usar tanto en disco como en cinta. En un archivo organizado secuencialmente, los registros quedan grabados consecutivamente cuando el archivo se usa como entrada y tiene una marca final que indica el fin del archivo

Registro 1 Registro 2 : Registro n-1 Registro n FIN

Principio de archivo

Fin de archivo

Ubicacin lgica y fsica de los registros en un archivo secuencial En los archivos secuenciales distinguimos dos tipos de ubicacin. Ubicacin lgica .- se refiere a la estructura lgica de cmo se organiza la informacin. La informacin lgica podra estar almacenadas fsicamente en uno o ms archivos de un disco rgido. Ubicacin fsica .- es aquella donde el contenido de los datos del registro determina su posicin fsica La organizacin fsica del archivo en una cinta o disco se corresponde exactamente con la ubicacin lgica del archivo

Ejemplo

Ubicacin lgica

Ubicacin fsica

En este archivo los registros tienen la siguiente estructura: class ALUMNO{ int codigo; // 2 bytes char nombre[50]; //50 bytes : }; Haciendo la suma encontramos que cada registro del archivo tiene un tamao de 52 bytes

0 1 2 3 4

0 52 104 156 208

907 789 123 786 567

Elena Maria Juan Elena Angela

Archivos, manejo de flujos Primera parte C++ C++ provee las siguientes clases para realizar operaciones de entrada y salida de caracteres hacia o desde archivos: ofstream: El flujo para escribir archivos. ifstream: El flujo para leer archivos. fstream: Flujo de lectura/escritura sobre archivos

Abrir archivos La primera operacin que se realiza sobre un objeto de una de estas clases es asociarlo a un archivo fsico. Este procedimiento es conocido como abrir archivo. Para realizar esta apertura utilizamos la funcin miembro de la clase open(archivo , modo);, dnde archivo es una secuencia de caracteres terminada en nulo del tipo const char * que representa el nombre del archivo fsico a ser abierto, y mode son una serie de parmetros opcionales que se detallan en la siguiente tabla: ios::in ios::out Modo de operaciones de entrada. Modo de operaciones de salida. Ubica la posicin inicial al final del archivo, s este parmetro se omite, la posicin inicial queda al principio del archivo. Todas las operaciones de salida son realizadas al final del archivo, haciendo append (agregar al final). Slo puede usarse en flujos abiertos slo de salida. Si el archivo abierto para operaciones de salida ya existe fsicamente, el contenido se borra y ser reemplazado por el nuevo que se introduzca

ios::binary Opera en modo binario. ios::ate ios::app ios::trunc

Las opciones de la tabla anterior pueden combinarse utilizando el operador OR ( | ). Por ejemplo si quisieramos abrir un archivo de ejemplo, llamado ejemplo.bin en modo binario, para agregar datos al final del archivo, podramos utilizar la sentencia: ofstream SalidaBinaria; SalidaBinaria.open ("ejemplo.bin", ios::out | ios::app | ios::binary); Para las clases ifstream y ofstream, son asumidos automtica y respectivamente los argumentos, ios::in y ios::out Podemos hacer la operacin de apertura mediante el uso del constructor del objeto al momento de instanciarlo, por ejemplo: ofstream MiArchivo ("ejemplo.bin", ios::out | ios::app | ios::binary); Para verificar que un archivo fue abierto correctamente, podemos utilizar la funcin miembro de la clase member is_open() que devuelve un valor booleano, true si la apertura fue correcta, false en caso contrario. Por ejemplo: if (MiArchivo.is_open()) { /* operamos con el archivo */ } else { /* manejamos el error */ } Cerrar el archivo Cuando terminemos de usar el archivo debemos cerrarlo, as nuestro programa devolver el recurso al sistema operativo nuevamente. Para hacerlo nos valemos de la funcin miembro close(), esta funcin no toma parmetros y lo que hace es terminar de escribir todo lo que haya quedado en los buffers y luego cerrar el archivo:

MiArchivo.close() Archivos binarios Hay dos formas de escribir y leer datos binarios a o desde un archivo. Primero se puede escribir un byte usando la funcin miembro put() y leer un byte usando la funcion miembro get() y la segunda forma que nos interesa aplicar en el tema de filas secuenciales es escribiendo y leyendo bloques de datos binarios, usando la funciones miembros read y write. /* Escribimos datos enteros en un archivo binario Observacin: En versiones anteriores de dev C++ en lugar de usar reinterpret_cast<char *>(&x) se usa (unsigned char *)&x */ #include <conio.h> #include <iostream.h> #include <fstream.h> class ENTERO{ int num; public: void REGISTRAR(int x){ ofstream esc("ejemplo1",ios::app| ios::binary); if(!esc){ cout<<"archivos on problemas";getch(); } else{ esc.write(reinterpret_cast<char *>(&x),sizeof(ENTERO)); esc.close(); } } void MOSTRAR(){ int y; ifstream lec("ejemplo1"); if(!lec){ cout<<"archivos con problemas";getch(); } else { lec.read(reinterpret_cast<char *>(&y),sizeof(ENTERO)); while(!lec.eof()){ cout<<"\n"<<y; lec.read(reinterpret_cast<char *>(&y),sizeof(ENTERO)); } lec.close(); } } }; int main(){ char op; int dato; ENTERO e; for(;;){ cout<<" \n adicionar <1>"; cout<<" \n Mostrar <2>"; cout<<" \n salir <3>"; op=getch(); switch(op){ case '1':cout<<"\n Ing entero :";cin>>dato; e.REGISTRAR(dato);break; case '2':e.MOSTRAR();getch(); break; case '3':return 0; } } }

Archivos de texto Los archivos de texto usan para leer y escribir los operadores << y >>. Estos archivos se usan para almacenar texto y otros valores como TABULACIONES y caracteres de nueva lnea que tendrn interpretaciones especiales y no tomados literalmente como en un archivo en modo binario. Las operaciones son las mismas que podemos asociarle al flujo de salida estndar cout: #include <iostream.h> #include <fstream.h> #include "conio.h" class TEXTO{ char linea[100]; public: void escribir(char tira[]){ ofstream MiArchivo ("ejemplo.txt"); if (MiArchivo.is_open()){ MiArchivo <<tira; MiArchivo.close(); } else cout << "ERROR: No se puedo realizar la apertura del archivo"; } void leer(){ ifstream MiArchivo ("ejemplo.txt"); if (MiArchivo.is_open()) { MiArchivo>>linea; while (! MiArchivo.eof() ){ cout << linea << endl; MiArchivo>>linea; } MiArchivo.close(); } else cout << "No se pudo abrir el archivo."; } }; int main () { TEXTO t; t.escribir("Hola soy cachimbo "); t.leer(); getch(); } Este ltimo ejemplo lee el archivo de texto e imprime su contenido en la pantalla. Notar como se llama a la funcin miembro eof() que devuelve verdadero en caso de que se haya alcanzado el fin de archivo. Ventajas de las filas secuenciales En cuanto a las ventajas, las filas secuenciales son ms sencillas de manejar, ya que requieren menos funciones En ocasiones pueden ser tiles, por ejemplo, cuando slo se quiere almacenar cierta informacin a medida que se recibe, y no interesa analizarla en el momento. Posteriormente, otro programa puede leer esa informacin desde el principio y analizarla.

Desventajas de las filas secuenciales Sin embargo, si el patrn de acceso al programa no es conforma al patrn de ordenamiento de los registros, entonces la eficiencia del programa puede ser terrible.

3. 4.

Para las aplicaciones interactivas que incluyen peticiones o actualizaciones de registros individuales, las filas secuenciales ofrecen un rendimiento pobre. REQUERIMIENTOS O MATERIAL Y EQUIPO Software Dev C++ 1 Diskete

PROCEDIMIENTO

El procedimiento consiste en dos pasos Especificacin del TAD y los algoritmos Implementacin del TAD

Ejercicio 1. Hacer el algoritmo y el programa que permita concatenar dos archivos de alumnos Especificacin del TAD y los algoritmos Especificacin ALUMNO variable entero : codigo cadena : nombre operaciones crear : no retorna valor IngresarAlumno : no retorna valor MostrarAlumno : no retornar valor REGISTRAR(fila, x) : no retornar valor VISUALIZAR(fila) : no retornar valor CONCATENAR(fila1,fila2, fila3): no retornar valor significado En REGISTRAR aadir x del tipo ALUMNO a fila En VISUALIZAR mostrar contenido de fila En CONCATENAR juntar contenidos de fila1, fila2 en fila3 Finespecificacion

procedimiento CONCATENAR(fila1, fila2, fila3) Inicio(fila1) Inicio(fila2) Inicio(fila3) Leer(fila1, valor) Mientras no Ultimo(fila1) hacer Escribir(fila3, valor) Leer(fila1, valor) Fin_mientras Cerrar(fila1) Leer(fila2, valor) Mientras no Ultimo(fila2) hacer Escribir(fila3, valor) Leer(fila2, valor) Fin_mientras Cerrar(fila2) Cerrar(fila3) Fin_CONCATENAR

Implementacin del TAD #include <conio.h> #include <iostream> #include <fstream> using namespace std; class ALUMNO{ int codigo; char nombre[40]; public: void IngresarAlumno(){ cout<<"\n leer codigo : ";cin>>codigo; cout<<"\n leer nombre : ";cin>>nombre; } void MostrarAlumno(){ cout<<"\n "<<codigo<<" "<<nombre; } void REGISTRAR(char fila[],ALUMNO x){ ofstream esc(fila,ios::app| ios::binary); if(!esc){ cout<<"\n ERROR al abrir "<<fila;getch(); } else{ esc.write(reinterpret_cast<char *>(&x),sizeof(ALUMNO)); esc.close(); } } void VISUALIZAR(char fila[]){ ALUMNO y; ifstream lec(fila); if(!lec){ cout<<"\n ERROR al abrir "<<fila;getch(); } else { cout<<"\n MOSTRANDO DATOS DEL ARCHIVO "<<fila; lec.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); while(!lec.eof()){ y.MostrarAlumno(); lec.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); } lec.close(); } } void CONCATENAR(char fila1[],char fila2[],char fila3[]){ ALUMNO y; ifstream F1(fila1); ifstream F2(fila2); ofstream F3(fila3, ios::out|ios::trunc |ios::binary); if(!F3){ cout<<"\n ERROR al abrir "<<fila3;getch(); } else{ if(!F1){ cout<<"\n ERROR al abrir "<<fila1;getch(); } else { F1.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); while(!F1.eof()){ F3.write(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); F1.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); } F1.close(); } F1.close(); if(!F2){ cout<<"\n ERROR al abrir "<<fila2;getch(); }

else { F2.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); while(!F2.eof()){ F3.write(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); F2.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); } F1.close(); } F1.close(); F3.close(); } } }; int main(int argc, char *argv[]){ char op; ALUMNO a; for(;;){ cout<<" \n adicionar fila1 <1>"; cout<<" \n adicionar fila2 <2>"; cout<<" \n Mostrar filas <3>"; cout<<" \n Concatenar filas <4>"; cout<<" \n salir <5>"; op=getch(); switch(op){ case '1':a.IngresarAlumno(); a.REGISTRAR("fila1",a);break; case '2':a.IngresarAlumno(); a.REGISTRAR("fila2",a);break; case '3':a.VISUALIZAR("fila1"); a.VISUALIZAR("fila2"); a.VISUALIZAR("fila3"); getch(); break; case '4':a.CONCATENAR("fila1","fila2","fila3");break; case '5':return 0; } } } Ejercicio 2 Se desea hacer un programa que permita separar a los alumnos con promedio impar en un archivo y los que estn con promedio par en otro archivo Especificacin del TAD y los algoritmos Especificacin ALUMNO variable entero : codigo cadena : nombre real: promedio operaciones crear : no retorna valor IngresarAlumno : no retorna valor MostrarAlumno : no retornar valor REGISTRAR(fila, x) : no retornar valor VISUALIZAR(fila) : no retornar valor PAR(nota) : retorna un valor booleano SEPARAR(fila1,fila2, fila3): no retornar valor significado

En REGISTRAR aadir x del tipo ALUMNO a fila En VISUALIZAR mostrar contenido de fila En SEPARAR registrar alumnos con promedio impar en fila2 y con promedio par en fila3 En PAR si nota del promedio es par retorna verdadero sino falso Fin_ALUMNO

Funcin PAR(nota): lgico real: nota mientras (nota >=2) nota nota - 2 finhacer si (nota= 0 ) entonces retornar verdadero sino retornar falso Finsi Fin_PAR procedimiento SEPARAR(fila1, fila2, fila3) inicio(fila1) inicio(fila2) inicio(fila3) leer(fila1, alum) mientras( no Ultimo(fila1)) hacer si(PAR(alum.promedio)) entonces escribir(fila3, alum) sino escribir(fila2, alum) finsi leer(fila1, alum) fin_mientras cerrar(fila1) cerrar(fila2) cerrar(fila3) fin_SEPARAR Implementacin del TAD #include <conio.h> #include <iostream> #include <fstream> using namespace std; class ALUMNO{ int codigo; char nombre[40]; float promedio; public: void IngresarAlumno(){ cout<<"\n leer codigo : ";cin>>codigo; cout<<"\n leer nombre : ";cin>>nombre; cout<<"\n leer promedio : ";cin>>promedio; } void MostrarAlumno(){ cout<<"\n "<<codigo<<" "<<nombre<<" "<<promedio; } void REGISTRAR(char fila[],ALUMNO x){ ofstream esc(fila,ios::app| ios::binary); if(!esc){ cout<<"\n ERROR al abrir "<<fila;getch(); }

else{ esc.write(reinterpret_cast<char *>(&x),sizeof(ALUMNO)); esc.close(); } } void VISUALIZAR(char fila[]){ ALUMNO y; ifstream lec(fila); if(!lec){ cout<<"\n ERROR al abrir "<<fila;getch(); } else { cout<<"\n MOSTRANDO DATOS DEL ARCHIVO "<<fila; lec.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); while(!lec.eof()){ y.MostrarAlumno(); lec.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); } lec.close(); } } bool PAR(float nota){ while (nota>=2){ nota-=2; } if(nota==0) return true; else return false; } void SEPARAR(char fila1[],char fila2[],char fila3[]){ ALUMNO y; ifstream F1(fila1); ofstream F2(fila2, ios::out| ios::trunc|ios::binary); ofstream F3(fila3, ios::out| ios::trunc|ios::binary); if(!F1){ cout<<"\n ERROR al abrir "<<fila3;getch(); } else{ F1.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); while(!F1.eof()){ if(PAR(y.promedio)) F3.write(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); else F2.write(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); F1.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); } F1.close(); F2.close(); F3.close(); } } }; int main(int argc, char *argv[]){ char op; ALUMNO a; for(;;){ cout<<" \n adicionar fila1 <1>"; cout<<" \n Mostrar filas <2>"; cout<<" \n Separar filas <3>"; cout<<" \n salir <4>"; op=getch(); switch(op){ case '1':a.IngresarAlumno();

a.REGISTRAR("fila1",a);break; case '2':a.VISUALIZAR("fila1"); a.VISUALIZAR("fila2"); a.VISUALIZAR("fila3"); getch(); break; case '3':a.SEPARAR("fila1","fila2","fila3");break; case '4':return 0; } } }

Ejercicio 3. Se desea hacer un programa que permita hacer una copia de los alumnos Especificacin del TAD y los algoritmos Especificacin ALUMNO variable entero : cdigo cadena : nombre operaciones IngresarAlumno : no retorna valor MostrarAlumno : no retornar valor REGISTRAR(fila, x) : no retornar valor VISUALIZAR(fila) : no retornar valor COPIAR(fila1,fila2) : no retornar valor significado En REGISTRAR aadir x del tipo ALUMNO a fila En VISUALIZAR mostrar contenido de fila Fin_ALUMNO procedimiento COPIAR(fila1 , fila2) inicio(fila1) inicio(fila2) leer(fila1, dato) mientras(no Ultimo(fila)) hacer escribir(fila2, dato) leer(fila1, dato) fin_mientras cerrar(fila1) cerrar(fila2) fin_COPIAR Implementacin del TAD

#include <conio.h> #include <iostream> #include <fstream> using namespace std; class ALUMNO{ int codigo; char nombre[40]; public: void IngresarAlumno(){

cout<<"\n leer codigo : ";cin>>codigo; cout<<"\n leer nombre : ";cin>>nombre; } void MostrarAlumno(){ cout<<"\n "<<codigo<<" "<<nombre; } void REGISTRAR(char fila[],ALUMNO x){ ofstream esc(fila,ios::app| ios::binary); if(!esc){ cout<<"\n ERROR al abrir "<<fila;getch(); } else{ esc.write(reinterpret_cast<char *>(&x),sizeof(ALUMNO)); esc.close(); } } void VISUALIZAR(char fila[]){ ALUMNO y; ifstream lec(fila); if(!lec){ cout<<"\n ERROR al abrir "<<fila;getch(); } else { cout<<"\n MOSTRANDO DATOS DEL ARCHIVO "<<fila; lec.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); while(!lec.eof()){ y.MostrarAlumno(); lec.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); } lec.close(); } } void COPIAR(char fila1[],char fila2[]){ ALUMNO y; ifstream F1(fila1); ofstream F2(fila2, ios::out| ios::trunc|ios::binary); if(!F1){ cout<<"\n ERROR al abrir "<<fila1;getch(); } else{ F1.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); while(!F1.eof()){ F2.write(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); F1.read(reinterpret_cast<char *>(&y),sizeof(ALUMNO)); } F1.close(); F2.close(); } } }; int main(int argc, char *argv[]){ char op; ALUMNO a; for(;;){ cout<<" \n adicionar fila1 <1>"; cout<<" \n Mostrar filas <2>"; cout<<" \n Copiar filas <3>"; cout<<" \n salir <4>"; op=getch(); switch(op){ case '1':a.IngresarAlumno(); a.REGISTRAR("fila1",a);break; case '2':a.VISUALIZAR("fila1"); a.VISUALIZAR("fila2");

getch(); break; case '3':a.COPIAR("fila1","fila2");break; case '4':return 0; } } }

Ejercicio 4. Se requiere un programa que permita insertar un alumno en un archivo de alumnos segn una posicin que especifique en el archivo Especificacin ALUMNO variable entero: cdigo cadena: nombre operaciones IngresarAlumno : no retorna valor MostrarAlumno : no retornar valor REGISTRAR(fila, x) : no retornar valor VISUALIZAR(fila) : no retornar valor INSERTAR(fila1,fila2, x, posicion) : retornar booleano Ecuaciones En REGISTRAR aadir x del tipo ALUMNO a fila En INSERTAR se registrara el nuevo dato x en la fila2 en una ubicacin de la fila1 especificada por la variable posicin. Fin_ALUMNO funcin insertaralumno(fila1, fila2, x, posicin): lgico ALUMNO : x entero : posicin insertar falso Indice 0 Inicio(fila1) Inicio(fila2) Leer(fila, dato) Mientras no ultimo(fila1) hacer Si posicin = ndice entonces insertar verdadero Escribir(fila2, x) finsi Escribir(fila2, dato) Leer(fila1, dato) indice indice + 1 Fin_mientras Cerrar(fila1) Cerrar(fila2) retornar insertar fininsertar

Ejercicio 5. Se requiere un programa que intercale los registros de dos archivos uno de alumnos varones y otro de damas. Los alumnos ambos damas y varones deben tener como datos el cdigo, nombre y edad. Ejemplo Entrada

Alumnos : A, D, C , E Alumnas : M, N Salida Intercalado: A, M, D, N, C, E Ejercicio 6 Se requiere un programa que genere la unin de dos archivos. Cada archivo contendr alumnos los cuales tienen como informacin cdigo, nombre y edad. Ejemplo Entrada Alumnos1 : A, D, C , E, M Alumnos2 : M, N Salida Unin Ejercicio 7 : A, D, C, E, M, N

Escriba un programa que intercambie dos registros de un archivo de alumnos. El programa debe asegurarse que los registros existan y luego hacer el intercambio. Ejemplo Entrada Alumnos1 : A, D, C , E, M Leer : M Leer A Salida Alumnos2 : M, D, C, E, A Ejercicio 8

Escriba la especificacin, los algoritmos y el programa que permita eliminar todos los nmeros repetidos en una fila. Ejemplo entrada Fila 1: 2, 5, 2, 8, 3, 3, 9, 3 Salida Fila2: 5, 8, 9 Ejercicio 9

Escriba la especificacin, los algoritmos y el programa que permita eliminar la redundancia de los nmeros en una fila. Ejemplo entrada Fila 1: 2, 5, 2, 8, 3, 3, 9, 3 Salida Fila2: 2, 5, 8, 3, 9

5.

ANALISIS DE RESULTADOS En filas secuenciales, la informacin slo puede leerse y escribirse empezando desde el principio de la fila. La escritura de nuevos datos siempre se hace al final de la fila. Para leer una zona concreta de la fila hay que avanzar siempre, si la zona est antes de la zona actual de lectura, ser necesario "rebobinar" la fila. Las filas slo se pueden abrir para lectura o para escritura, nunca de los dos modos a la vez. Esto es en teora, por supuesto, en realidad C no distingue si los archivos que usamos son secuenciales o no, es el tratamiento que hagamos de ellos lo que los clasifica como de uno u otro tipo.

6.

BIBLIOGRAFIA

Estructura de Datos, Un Enfoque Algortmico. Manuel Gallardo O., Teodomiro Prez C. Tenenbaum A. M., Langsam Y., Augenstein,M.A., (1993) Estructura de Datos en C, 2 Ed. Mxico D.F., Prentice Hall Hispanoamericana S.A. Joyanes Aguilar, L., Sanchez Garcia, L., Fernadez Azuela, M. Zahonero Martinez, I.,(2005) Estructura de Datos en C, Madrid, Mc Graw-Hill - Interoamericana. Cair O., Guardati M.C. S., (2002) Estructura de Datos, 2. Ed. Mxico D.F., Mc Graw-Hill / Interamericana Editores S.A.

También podría gustarte