INTRODUCCION:

La computadora procesa distintos tipos de informacin en forma de datos, estos datos pueden ocupar uno o varios espacios en la memoria, por lo que se les puede considerar como simples o estructurados, los datos simples son los que solo ocupan un espacio de la memoria mientras que los datos estructurados necesitan varios espacios de la memoria. Las estructuras de datos se ocupan de organizar y relacionar los diferentes tipos de datos que se manejan, adems de controlar la forma en se almacenan y como es que se puede acceder a elementos particulares de los datos.

Con esta investigacin se prentende explicar cada una de estas estructuras de acuerdo a la siguiente clasificacin:

Vectores y Matrices Estruturas Estticas: Registros Archivos

ESTRUCUTRAS DINAMICAS LINEALES I. Listas enlazadas simples, dobles y circulares. II. Pilas III. Colas IV. Bicolas

ESTRUCTURAS DINAMICAS NO LINEALES I. rboles i. rboles Binarios ii. rboles Binarios de bsquedas II. Grafos

 ESTRUCTURA DE DATOS ESTTICAS:

Son aquellas en las que el espacio ocupado en memoria se define en tiempo de compilacin y no puede ser modificado durante la ejecucin del programa. Corresponden a este tipo los arrays y registros Arrays: Un arreglo (array) es una coleccin de datos del mismo tipo, que se almacenan en posiciones consecutivas de memoria y reciben un nombre comn. Para referirse a un determinado elemento de un array se deber utilizar un ndice, que especifique su posicin relativa en el array. Un arreglo es una coleccin finita, homognea y ordenada de elementos. Finita:Todo arreglo tiene un lmite; es decir,debe determinarse cul ser el nmero mximo de elementos que podrn formar parte del arreglo. Homognea: Todos los elementos del arreglo deben ser del mismo tipo. Ordenada: Se puede determinar cul es el primer elemento, el segundo, el tercero,.... y el n-simo elmento. Los arreglos se clasifican de acuerdo con el nmero de dimensiones que tienen. As se tienen los: - Unidimensionales (vectores) - Bidimensionales (tablas o matrices) - Multidimensionales (tres o ms dimensiones)

PROBLEMA. Suponga que se desea desarrollar un programa para: 1.Leer una lista de calificaciones de un examen 2.Encontrar su media 3.Escribir una lista de las calificaciones mayores que la media 4.Ordenar la lista de las calificaciones en orden ascendente. Supongamos tambin que hay 100 calificaciones. Debemos utilizar 100 variables diferentes nota1, nota2, ...., nota100, de ese modo son 100 direcciones diferentes de memoria para almacenar las calificaciones del examen. Se imagina declarar las 100 variables, cuntas instrucciones involucra? Var Nota1,nota2,nota3,.........nota100: entero (En la declaracin real de un programa no pueden usarse puntos suspensivos, por lo tanto sern 100 veces) . En la fase de lectura de datos, sern tambin 100 veces las instrucciones para ir leyendo cada valor. Leer (nota1, nota2,nota3,........., nota100) Para calcular la media: Media (nota1+nota2+.......+nota100)/100 Para la lista de calificaciones mayores que la media, deber tambin irse comparando una por una: Si nota1 > media entonces escribir (nota1) Fin_si Si nota2 > media entonces escribir (nota2) Fin_si Si nota100 > media entonces escribir (nota100) Fin_si Y despus de ms de 450 lneas de cdigo..... Falta ordenar la lista de calificaciones en orden ascendente! Despus que aprendas a usar arreglos vers cmo se ahorra instrucciones porque es fcil recorrer toda la lista de notas con unas pocas instrucciones. En el caso anterior, cuando el acceso a la informacin es secuencial, slo se puede acceder a un elemento buscando desde el principio de la lista, y esto es algo lento. Lo que se necesita es una estructura de acceso directo que permita almacenar y recuperar los datos directamente especificando su posicin en la estructura, de esa manera se requerir el mismo tiempo para acceder al elemento de la posicin 100 que el de la posicin 5. Tambin preferiremos que esta estructura se almacene en memoria principal para que su almacenaje y recuperacin sea ms rpida. Es por ello que existen los arreglos, que estn organizados en una secuencia de elementos, todos del mismo tipo y se puede acceder a cada elemento directamente especificando su posicin en esta secuencia. Arreglos Unidimensionales: Estn formados por un conjunto de elementos de un mismo tipo de datos que se almacenan bajo un mismo nombre, y se diferencian por la posicin que tiene cada elemento dentro del arreglo de datos. Al declarar un arreglo, se debe inicializar sus elementos antes de utilizarlos. Para declarar un arreglo tiene que indicar su tipo, un nombre nico y la cantidad de elementos que va a contener. Por ejemplo, las siguientes instrucciones declaran tres arreglos distintos:

Float costo_partes[50]; Para acceder a valores especficos del arreglo, use un valor de ndice que apunte al elemento deseado. Por ejemplo, para acceder al primer elemento del arreglo calificaciones debe utilizar el valor de ndice 0 (calificaciones[0]). Los programas en C++ siempre indizan el primer elemento de un arreglo con 0 y el ltimo con un valor menor en una unidad al tamao del arreglo. Inicializacin y asignacin de valores Como se deca anteriormente, antes de utilizar un arreglo es necesario inicializarlo: Calificaciones[0]; Para inicializar todos los elementos de una vez, se colocan dentro de una estructura for que va del primer elemento al ltimo que contiene el arreglo. Para asignar un valor a un elemento del arreglo se hace por ejemplo: Calificaciones[0] 100; Cuando se usan arreglos, una operacin comn es usar una variable ndice para acceder a los elementos de un arreglo. Suponiendo que la variable ndice I contiene el valor 3, la siguiente instruccin asigna el valor 400 a valores[3]: valores[I] 400; Partes de un arreglo: Los componentes. Hacen referencia a los elementos que forman el arreglo, es decir, a los valores que se almacenan en cada una de las casillas del mismo. Los ndices. Permiten hacer referencia a los componentes del arreglo en forma individual, especifican cuntos elementos tendr el arreglo y adems, de qu modo podrn accesarse esos componentes. Definicin de Arreglos: ident_arreglo = arreglo[liminf .. Limsup] de tipo Operaciones con Vectores: Las operaciones que se pueden realizar con vectores durante el proceso de resolucin de un problema son: Lectura/ escritura Asignacin Actualizacin(insercin, eliminacin, modificacin)

 Recorrido (acceso secuencial) Ordenacin Bsqueda Ejemplos: Sea arre un arreglo de 70 elementos enteros con ndices enteros. Su representacin nos queda:

Ejemplos: Sea bool un arreglo de 26 elementos booleanos con ndices de tipo caracter. Su representacin nos queda: Bool = arreglo["a".."z"] de booleanos

Nmero total de elementos: NTE= (ord("z")-ord("a")) + 1 = 122-97+1 = 26 elementos Lectura El proceso de lectura de un arreglo consiste en leer y asignar un valor a cada uno de sus elementos. Normalmente se realizan con estructuras repetitivas, aunque pueden usarse estructuras selectivas. Usamos los ndices para recorrer los elementos del arreglo: desde i = 1 hasta 70 hacer leer ( arre[i]) fin_desde Escritura: Es similar al caso de lectura, slo que en vez de leer el componente del arreglo, lo escribimos. leer (N) desde i = 1 hasta N hacer escribir (arre[i]) fin_desde Asignacin: No es posible asignar directamente un valor a todo el arreglo; sino que se debe asignar el valor deseado en cada componente. Con una estructura repetitiva se puede asignar un valor a todos los elementos del vector. Por ejemplo: arre[1] 120 (asignacin de un valor constante nico a una casilla del vector) arre[3] arre[1] / 4 (asignar una operacin)

Se puede asignar un valor constante a todos los elementos del vector:desde i = 1 hasta 5 hacer arre[i] 3 fin_desde O bien arre 3 (con arre del tipo arreglo) Inicializacin Para inicializar con cero todos los elementos del arreglo: desde i = 1 hasta 70 hacer arre[i] 0 fin_desde Acceso Secuencial. (Recorrido) El acceso a los elementos de un vector puede ser para leer en l o para escribir (visualizar su contenido). Recorrido del vector es la accin de efectuar una accin general sobre todos los elementos de ese vector. Actualizacin. Incluye aadir (insertar), borrar o modificar algunos de los ya existentes. Se debe tener en cuenta si el arreglo est o no ordenado. Aadir datos a un vector consiste en agregar un nuevo elemento al final del vector, siempre que haya espacio en memoria. Una estructura lineal de datos o lista est conformada por ninguno, uno o varios elementos que tienen una relacin de adyacencia ordenada donde existe un primer elemento, seguido de un segundo elemento y as sucesivamente hasta llegar al ltimo. El tipo de dato de los elementos puede ser cualquiera, pero debe ser el mismo tipo para todos. El valor contenido en los elementos puede ser el mismo o diferente. En estas estructuras se realizan operaciones de agregar y/o eliminar elementos a la lista segn un criterio particular. Sobre la base de la forma y el lugar de la realizacin de estas operaciones en la misma, las listas se clasifican en listas de acceso restringido y listas de acceso no restringido. Las listas de acceso restringido son las pilas, colas y dipolos. En las pilas, las operaciones de acceso se realizan por un nico extremo de la lista, al cual normalmente se denomina tope de la pila. En las colas, estas operaciones se realizan por ambos extremos de la lista llamados generalmente, inicio y fin de la cola. Finalmente, en los dipolos que son colas dobles, las operaciones se realizan tambin por ambos extremos de la lista, en este caso todas las operaciones se pueden hacer por ambos extremos, es decir se puede insertar o eliminar elementos por el tope o por el fin, a diferencia de la cola donde se inserta siempre por el fin y se elimina por el tope. Se puede entonces considerar al dipolo como una clase general de la clase cola.

ARCHIVOS
Definicin y Componentes Es una es estructura de datos que reside en memoria secundaria o almacenamiento permanente (cinta magntica, disco magntico, disco ptico, disco lser, etc.). La forma de clasificacin ms bsica se realiza de acuerdo al formato en que residen estos archivos, de esta forma hablamos de archivos ASCII (de texto) y archivos binarios. En este captulo nos centraremos en estos ltimos. Definicin archivo binario:

Estructura de datos permanente compuesto por registros (filas) y stos a su vez por campos (columnas). Se caracteriza por tener un tipo de dato asociado, el cual define su estructura interna. Definicin archivo texto: Estructura de datos permanente no estructurado formado por una secuencia de caracteres ASCII.

Ejemplo: Definicin y creacin de un archivo en Pascal. Type {Definicin de la estructura del registro} Reg_archivo = Record Key : Integer; {Campo clave o identificador} data : String[20] ;{Campo de datos} End; Var R : reg_archivo; {Declaracin de variables asociadas al archivo} A : File of reg_archivo; {Nombre lgico del archivo} Program prueba; Type Reg_archivo = Record Key : Integer; Data : String[20]; End; Var R : reg_archivo; A : File of reg_archivo; I : Integer; Begin Assign(a,'archivo.dat'); {se asigna el nombre lgico `a' al archivo} Rewrite(a); {se crea el archivo, si ste existe borra el contenido, dejndolo listo para el ingreso registros} For i:= 1 to 10 do Begin Write('ingrese clave ',i:2,':'); readln(r.key); Write('Ingrese datos: '); readln(r.data); {se ingresa la informacin correspondiente al registro utilizado por el programa} write(a,r) {se `traspasa' el registro al archivo definido (al buffer asociado)} End; reset(a); {se posiciona un puntero en el primer registro del archivo} For i:= 1 to 10 do Begin read(a,r); {se lee del archivo a el registro indicado por el puntero, traspasando los Datos al registro r y el puntero avanza al siguiente registro} writeln(r.key,' ',r.data); End;

close(a) {se `cierra' el archivo traspasando, si fuera necesario, el buffer al archivo} End. Investiga otras funciones y procedimientos para el manejo de archivos. Tipos de Acceso a los Archivos Secuencial Se accesan uno a uno los registros desde el primero hasta el ltimo o hasta aquel que cumpla con cierta condicin de bsqueda. Se permite sobre archivos de Organizacin secuencial y Secuencial Indexada. Random Se accesan en primera instancia la tabla de ndices de manera de recuperar la direccin de inicio de bloque en donde se encuentra el registro buscado. (dentro del rea primaria o de overflow). Se permite para archivos con Organizacin Sec.Indexada. Dinmico Se accesan en primera instancia la tabla de ndices de manera de recuperar la direccin de inicio de bloque en donde se encuentra el registro buscado. (dentro del rea primaria o de overflow). Se permite para archivos con Organizacin Sec.Indexada. Directo Es aquel que utiliza la funcin de Hashing para recuperar los registros. Slo se permite para archivos con Organizacin Relativa. Clasificacin de los Archivos Segn su Uso La siguiente tabla resume las distintas denominaciones dadas a los archivos segn la utilizacin dada: Tipo Definicin Ejemplo Archivo de empleados en un Perduran durante todo el ciclo de vida de los Maestros sistema de sistemas. Remuneraciones. Se utilizan para actualizar otros archivos. Pueden Archivo de ventas diarias en Transaccionales ser eliminados al trmino de este proceso o un sistema de ventas. conservados como respaldos. De respaldo Son copias de seguridad de otros archivos Son creados y eliminados entro de un proceso De paso computacional. Registros de movimientos Histricos Registran acontecimientos a travs del tiempo. diarios de CC en un Sistema Bancario de CC. Corresponden a los archivos de consultas de Registro % imposiciones % De referencia parmetros. descuentos isapre, etc. Son respuestas del sistema computacional cuyos Planillas de sueldos en un Informes o contenidos deben ser interpretados por personas. sistema de Reportes Pueden ser en forma escrita, por pantalla e incluso Remuneraciones. hacia algn archivo con formato editable. Organizaciones Bsicas de Archivos Secuencial Es la organizacin ms comn. Los registros se almacenan uno tras otro por orden de llegada. Para accesar un registro determinado se deben leer todos los registros que estn almacenados antes que l. Se recomienda: para archivos de procesamiento batch (aquellos para los cuales se debe realizar la misma operacin sobre la mayor parte de sus registros) Secuencial Indexada Los registros son almacenados en una distribucin tal que permiten ser consultados a travs de ndices. En ellos se distinguen 3 reas de almacenamiento: 1.De ndices: Mecanismo de acceso a los registros de datos. 2.Primaria o de datos: En donde se encuentran los datos propiamente tal.

3.De overflow: Encargada de recibir aquellos registros que no pueden ser almacenados en el rea primaria. Se recomienda : Para archivos de consulta Relativa Existe una relacin directa entre la ubicacin lgica de un registro y su ubicacin fsica. Para ello necesita una funcin matemtica que asigne a un valor de clave una direccin fsica nica. El encontrar una Fh ptima es tarea compleja por lo que esta organizacin es poco utilizada. Se recomienda: Para archivos en donde sea crucial minimizar tiempos de acceso. Operaciones Bsicas de Archivos Consiste ordenar el archivo a partir de uno o ms criterios impuestos sobre sus campos. Es normal que los archivos estn ordenados por clave o por algn campo alfabtico ascendente o descendentemente Concatenacin Consiste en unir 2 ms archivos en uno (uno a continuacin del otro). Antes de...

Despus de........................................................................ Intercalacin Consiste en generar un archivo ordenado segn algn criterio preestablecido a partir de dos ms archivos que pueden o no encontrarse en la misma secuencia.

Antes de...

Despus de... Pareamiento Consiste en ubicar registros correspondientes entre 2 ms archivos. Consiste en ubicar aquellos pares de registros pertenecientes a dos archivos diferentes que cumplen una cierta relacin de correspondencia. Edicin Consiste en preparar los datos que constituyen a uno ms archivos para que sean interpretados por personas. Se asocia generalmente a la generacin de listados en papel impreso. Validacin Consiste en asegurar la veracidad e integridad de los datos que ingresan a un archivo. Existen numerosas tcnicas de validacin tales como: Dgito verificador, chequeo de tipo, chequeo de rango. Actualizacin Consiste en agregar y eliminar registros desde un archivo, as como tambin modificar el valor de uno ms campos. Tambin se conoce como mantencin de uno o ms archivos. Bases de Datos Una base de datos es un conjunto de archivos o tablas relacionadas almacenados en forma estructurada. Est formada adems por consultas e ndices. Existen ciertos enfoques para el diseo de BD: Relacional, Jerrquica y de Red. Las aplicaciones que permiten administrar una base de datos se denominan DBMS (Data Base Manager System), entre ellos podemos citar a: Access, SQL Server, ORACLE Server etc. Estas ltimas se conocen tambin como RDBMS (Relational Data Base Manager System) ya que siguen el enfoque relacional. En empresas de gran envergadura, se habla de Base de Datos Corporativa conformada por mltiples modelos de bases de datos pertenecientes a distintas instancias e interrelacionados entre s. En general, el diseo de las bases de datos se rige segn ciertas normas, algunas creadas por E. Codd permiten evitar redundancias, e inconsistencias como consecuencia del proceso de actualizacin. Estas reglas son las denominadas FORMAS NORMALES. Ejemplo: Esquema fsico relacional

P: Primary Key F: Foreing Key Notar que existe una relacin entre las tablas reparacin y producto representada la tabla relacin prod_reparpor, debido a que en una reparacin se pueden utilizar varios productos como insumos y stos a su vez pueden participar en ms de una reparacin. Formas Normales Las formas normales definidas en la teora de bases de datos relacionales representan lineamientos para el dise-o de registros. Las reglas de normalizacin estn dirigidas a la prevencin de anomalas de actualizacin y de inconsistencias en los datos. Ellas no reflejan ninguna consideracin de rendimiento. En cierta forma, pueden ser visualizadas como orientadas por el supuesto de que todos los campos no-clave sern actualizados frecuentemente. No hay obligacin de normalizar completamente todas las relaciones cuando se deben considerar aspectos de rendimiento (tiempo de acceso por consulta). Finalmente, podemos decir que estas formas normales tambin son aplicables al diseo de archivos tradicionales con clave, con lo que abarcaramos todos los sistemas. Aqu enunciamos las 2 primeras FN: REGISTROS

Un registro, en programacin, es un tipo de dato estructurado formado por la unin de varios elementos bajo una misma estructura. Estos elementos pueden ser, o bien datos elementales (entero, real, carcter,), o bien otras estructuras de datos. A cada uno de esos elementos se le llama campo. Un registro se diferencia de un vector en que ste es una coleccin de datos iguales, es decir, todos del mismo tipo, mientras que en una estructura los elementos que la componen, aunque podran serlo, no tiene porque ser del mismo tipo. En el caso del lenguaje Java, el equivalente a los campos de un registro son los atributos o campos de los objetos de una clase. En la notacin algortmica utilizada en clase, un tipo registro se declara as: tipo fecha = registro elDa:da; elMes:mes; elAo:natural freg

Se declaran variables as: variable aniversario:fecha Y se utilizan as: principio aniversario.elDa:=1; aniversario.elMes:=oct; {el tipo mes se ha definido por enumeracin, como mes=(ene,feb,mar,abr,may,jun,jul,ago,sep,oct,nov,dic)} aniversario.elAo:=2011; ... aniversario.elDa:=aniversario.elDa+1; .

ESTRUCTURAS DINMICAS DE DATOS

Son aquellas en las que el espacio ocupado en memoria puede ser modificado en tiempo de ejecucin. Corresponden a este tipo las listas, rboles y grafos. Estas estructuras no son soportadas en todos los lenguajes. La eleccin de la estructura de datos idnea depender de la naturaleza del problema a resolver y, en menor medida, del lenguaje. Las estructuras de datos tienen en comn que un identificador, nombre, puede representar a mltiples datos individuales. Existen 2 tipos de estructuras dinmicas: v ESTRUCUTRAS DINAMICAS LINEALES I. Listas enlazadas simples, dobles y circulares. II. Pilas III. Colas IV. Bicolas Operaciones Bsicas en Estructuras Lineales 1. Recorrido: Procesa c/elemento de la estructura. 2. Bsqueda: Recupera la posicin de un elemento especfico. 3. Insercin: Adiciona un nuevo elemento a la estructura. 4. Borrado: Elimina un elemento de la estructura. 5. Ordenacin: Ordena los elementos de la estructura de acuerdo a los valores que contiene. 6. Mezcla: Combina 2 estructuras en una sola.

ESTRUCTURAS DINAMICAS NO LINEALES I. rboles i. rboles Binarios ii. rboles Binarios de bsquedas II. Grafos En funcin de la forma en que se relacionan existen varios tipos de estructuras de datos. Este tipo de estructuras son autor referenciada, es decir, contienen entre sus campos un puntero de su mismo tipo. Las ms utilizadas son: - pilas - colas - listas

Las pilas Este tipo de estructuras se caracteriza porque todas las operaciones se realizan en el mismo lado. Es de tipo LIFO ( Last In First Out ), el ltimo elemento en entrar es el primero en salir. Ejemplo: /* Ejemplo de una pila. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void); struct pila { char nombre[20]; struct pila *ant; }*CAB=NULL,*AUX=NULL; main() /* Rellenar, extraer y visualizar */ { char opc; do { clrscr(); /* borramos la pantalla */ gotoxy(30,8); /* columna 30, fila 8 */ printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la pila"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); } void insertar(void)

{ AUX=(struct pila *)malloc(sizeof(struct pila)); clrscr(); printf("Nombre: "); gets(AUX->nombre); if (CAB==NULL) { CAB=AUX; AUX->ant=NULL; } else { AUX->ant=CAB; CAB=AUX; } } void extraer(void) { if (CAB==NULL) return; AUX=CAB; CAB=CAB->ant; free(AUX); } void visualizar(void) { if (CAB==NULL) return; clrscr(); AUX=CAB; while (AUX!=NULL) { printf("Nombre: %s\n",AUX->nombre); AUX=AUX->ant; } getch( ); }

La estructura tipo que utilizaremos ser sta: struct pila { tipo variables; struct pila *ant; }*CAB=NULL,*AUX=NULL; Donde tipo variables sern las diferentes variables que guardaremos en la estructura, struct pila *ant es un puntero que apunta al elemento de tipo pila introducido anteriormente, *CAB ser donde guardaremos el ltimo elemento insertado en la pila y *AUX nos servir para guardar elementos temporalmente y para recorrer la pila al visualizarla. Antes de insertar un elemento, deberemos comprobar si la pila est vaca o no. Si lo estuviera deberemos insertar el primer elemento: CAB=AUX;

CAB->ant=NULL;

Si ya hubiera algn elemento crearemos uno nuevo apuntado por AUX y haremos que AUX->ant apunte a CAB, que en este momento contiene la direccin del elemento insertado anteriormente. Tras esto haremos que CAB apunte al ltimo elemento insertado, que ser la nueva cabeza de la pila: AUX->ant=CAB; CAB=AUX;

Para extraer un elemento de la pila deberemos hacer que AUX apunte a la misma direccin que CAB, despus haremos que CAB apunte a CAB->ant, con lo que el elemento anterior pasar a ser la cabeza de la pila. Tras esto, solo queda liberar la memoria de la zona apuntada por AUX. No olvides controlar si existe algn elemento ( si CAB es igual a NULL la pila est vaca ): if (CAB==NULL) return; AUX=CAB; CAB=CAB->ant; free(AUX);

Por ltimo, para visualizar los elementos de la pila, haremos que el puntero auxiliar AUX apunte a la cabeza de la pila, o sea, a CAB. Tras esto iremos visualizando el contenido de la pila, haciendo que AUX tome la direccin de AUX->ant, mientras AUX sea distinto de NULL. Tambin es importante controlar que la pila no est vaca. if (CAB==NULL) return; AUX=CAB; while (AUX!=NULL) { printf("%s",AUX->nombre); AUX=AUX->ant; };

Estructura grfica de una pila:

OPERACIONES BASICAS -PUSH (insertar).- Agrega un elementos a la pila en el extremo llamado tope. -POP (remover).- Remueve el elemento de la pila que se encuentra en el extremo llamado tope. -VACIA.- Indica si la pila contiene o no contiene elementos. -LLENA.- Indica si es posible o no agregar nuevos elementos a la pila. EJEMPLO

APLICACIONES DE LAS PILA FUNCIONES RECURSIVAS Las pilas pueden ser usadas para implementar la recursin en programas. Una funcin o procedimiento recursivo es aquel que se llama a si mismo. Ejemplos:

Factorial Nmeros de Fibonacci Torres de Hanoi Algoritmos de Ordenamiento de datos Etc.

Las colas

Este tipo de estructuras se caracteriza porque insertamos los elementos por un lado y los extraemos por el otro lado. Es de tipo FIFO ( First In First Out ), el primer elemento en entrar es el primero en salir. Para gestionar la cola utilizaremos 3 punteros (para la pila solo eran necesarios 2 ).

/* Ejemplo de una cola. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void); struct cola { char nombre[20]; struct cola *sig; }*CAB=NULL,*AUX=NULL,*FIN=NULL; main() /* Rellenar, extraer y visualizar */ { char opc; do { clrscr(); gotoxy(30,8); printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la cola"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc) {

case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); } void insertar(void) { AUX=(struct cola *)malloc(sizeof(struct cola)); clrscr(); printf("Nombre: "); gets(AUX->nombre); AUX->sig=NULL; if (FIN==NULL) FIN=CAB=AUX; else { FIN->sig=AUX; FIN=AUX; } } void extraer(void) { if (CAB==NULL) return; AUX=CAB; CAB=CAB->sig; free(AUX); } void visualizar(void) { if (CAB==NULL) return; clrscr(); AUX=CAB; while (AUX!=NULL) { printf("Nombre: %s\n",AUX->nombre); AUX=AUX->sig; } getch(); } La estructura que utilizaremos ser: struct cola { tipo variables; struct cola *sig; }*CAB=NULL,*AUX=NULL,*FIN=NULL;

donde tipo variables sern las diferentes variables que guardaremos en la estructura, struct cola *sig es un puntero que apunta al elemento de tipo cola introducido a continuacin, *CAB ser donde guardaremos el primer elemento insertado en la cola, *AUX nos servir para guardar elementos temporalmente y para recorrer la cola al visualizarla y *FIN tomar la direccin del ltimo elemento insertado. Antes de insertar un elemento, deberemos comprobar si la cola est vaca o no. Si lo est deberemos insertar el primer elemento: if (FIN==NULL) CAB=FIN=AUX;

Si ya existiera algn elemento haremos que FIN->sig apunte al elemento de AUX y a continuacin haremos que FIN tome la direccin de AUX, con lo que FIN apuntar al ltimo elemento insertado. FIN->sig=AUX; FIN=AUX;

Para extraer un elemento de la cola haremos que el puntero auxiliar AUX tome la direccin del primer elemento insertado, que hemos guardado en CAB. Tras esto haremos que CAB apunte a CAB->sig, es decir, que tome la direccin del segundo elemento insertado, que ahora pasar a ser el primero. Luego liberaremos la zona de memoria apuntada por AUX: AUX=CAB; /* Deberemos controlar que no est vaca: if (CAB==NULL) return; */ CAB=CAB->sig; free(AUX);

Para visualizar la cola comprobaremos que existan elementos, esto es, que FIN sea distinto de NULL. Hecho esto asignaremos a AUX la direccin de CAB e iremos recorriendo la cola hasta que AUX sea igual a NULL. AUX=CAB; /* Deberemos controlar que no est vaca: if (CAB==NULL) return; */ while(AUX!=NULL) { printf("%s",AUX->nombre); AUX=AUX->sig; }

Estructura grfica de una cola:

OPERACIONES BASICAS CON COLAS Insertar.- Almacena al final de la cola el elemento que se recibe como paramtro. Eliminar.- Saca de la cola el elemento que se encuentra al frente. Vaca.- Regresa un valor booleano indicando si la cola tiene o no elementos (true si la cola esta vacia, false si la cola tiene al menos un elemento). Llena.- Regresa un valor booleano indicando si la cola tiene espacio disponible para insertar nuevos elementos ( true si esta llena y false si existen espacios disponibles).

Las listas Este tipo de estructuras se caracteriza porque los elementos estn enlazados entre s, de manera que adems de las acciones habituales de insertar, extraer y visualizar tambin podremos buscar un elemento. Para gestionar la lista utilizaremos 4 punteros. /* Ejemplo de una lista. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void);

void extraer(void); void visualizar(void); struct lista { int num; struct lista *sig; }*CAB=NULL,*AUX=NULL,*F=NULL,*P=NULL; main() /* Rellenar, extraer y visualizar */ { char opc; do { clrscr( ); gotoxy(30,8); printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la lista"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); } /* A continuacin insertaremos el elemento que vamos a crear en la posicin que le corresponda, teniendo en cuenta que la lista deber quedar ordenada de menor a mayor. El puntero P comprueba si el campo num de un elemento es menor que el campo num del elemento introducido. El puntero F se quedar apuntando al elemento de la posicin anterior al elemento que hemos insertado */ void insertar(void) { AUX=(struct lista *)malloc(sizeof(struct lista)); clrscr( ); printf("Introduce un nmero: "); scanf("%d",&AUX->num); AUX->sig=NULL; if (CAB==NULL) CAB=AUX; else if (CAB->num > AUX->num) { AUX->sig=CAB;

CAB=AUX; } else { P=F=CAB; while (P->num < AUX->num && P!=NULL) { if (P==CAB) P=P->sig; else { P=P->sig; F=F->sig; } } AUX->sig=F->sig; F->sig=AUX; } } void extraer(void) { int var; if (CAB==NULL) return; clrscr( ); printf("Introduce el nmero a extraer: "); scanf("%d",&var); if (CAB->num==var) { P=CAB; CAB=CAB->sig; free(P); } else { P=F=CAB; while (P->num != var && P!=NULL) { if (P==CAB) P=P->sig; else { P=P->sig; F=F->sig; } } if (P==NULL) return; F->sig=P->sig; free(P); } } void visualizar(void) { if (CAB==NULL) return; clrscr( ); AUX=CAB; while (AUX!=NULL)

{ printf("Nmero: %d\n",AUX->num); AUX=AUX->sig; } getch( ); } La estructura que utilizaremos ser: struct lista { tipo variables; struct lista *sig; }*CAB=NULL,*AUX=NULL,*F=NULL,*P=NULL; Donde tipo variables sern las variables que guardaremos en la estructura, struct lista *sig es un puntero que apunta al elemento de tipo lista introducido a continuacin, *CAB ser donde g uardaremos el primer elemento de la lista, *AUX nos servir para guardar elementos temporalmente y para recorrer la lista al visualizarla, *P para comparar los valores introducidos y ordenarlos, y *F, que apuntar al elemento anterior al ltimo introducido. Antes de insertar un elemento, deberemos comprobar si la lista est vaca o no. Si lo est deberemos insertar el primer elemento: if (CAB==NULL) CAB=AUX;

Si ya existiera algn elemento haremos que P y F apunten al primero de la lista. Si el elemento introducido fuera menor que el primero de la lista, haramos que el nuevo elemento pasara a ser el primero, y el que hasta ahora era el primero, pasara a ser el segundo. if (AUX->num < CAB->num){ AUX->sig=CAB; CAB=AUX; }

Para extraer un elemento de la lista solicitaremos un nmero, si el nmero introducido se corresponde con el campo num de uno de los elementos, ste ser extrado de la lista. Deberemos controlar que la lista no est vaca y que el elemento con el nmero solicitado exista. Fjate en el ejemplo, en la funcin extraer. Si CAB es igual a NULL, ser que la lista est vaca, y si P es igual a NULL al salir del while significar que no se ha encontrado ningn elemento que contenga el nmero introducido. Para visualizar la lista comprobaremos que existan elementos, es decir, que CAB sea distinto de NULL. Hecho esto asignaremos a AUX la direccin de CAB e iremos recorriendo la lista mientras AUX sea distinto de NULL. if (CAB==NULL) return; AUX=CAB; while(AUX!=NULL) { printf("%d",AUX->num); AUX=AUX->sig; }

Estructura grfica de una lista:

OPERACIONES BASICAS CON LISTAS SIMPLES Insertar: Agrega un elemento a la lista. Eliminar: Retira un elemento de la lista. Buscar: Busca un elemento en la lista. Recorrer: Visita todos los elementos de la lista. Vaca: Indica si la lista contiene o no elementos. Tamao: Indica el nmero de elementos de la lista.

Con las operaciones anteriores, define una interfase para una lista simple que contiene datos de tipo String. LISTAS ENLAZADAS Una lista enlazada es una coleccin lineal de objetos de una clase de autorreferencia llamados nodos y conectados mediantes enlaces de referencias, de ah el trmino de lista enlazadas. Accedemos una lista enlazada a travs de una referencia al primer nodo de la lista. Accedemos a los nodos subsecuentes a travs del miembro de referencia de enlace almacenado en cada nodo. Por convencin, la referencia de enlace al ltimo nodo se pone en null, para marcar el final de lista. Los datos se almacenan en una lista enlazada dinmicamente: se crea un nodo cada vez que se necesite uno. Un nodo puede contener datos de cualquier tipo, e incluso objeto de otra clase. Las Colas y Pilas tambin son estructuras da datos lineales y como veremos luego son versiones restringidas de la lista enlazada. OPERACIONES Las operaciones que podemos realizar con este tipo de estructuras dinmicas lineales son:

Insertar I. II. III. Eliminar Al frente Posterior Posicin n de la lista I. II. III. Al frente Posterior Posicin n de la lista Al frente Posterior Posicin n de la lista

Modificar I. II. III.

v v

Buscar Ordenar

Para trabajar con las operaciones de la lista como las inserciones, eliminaciones y modificaciones, debemos tomar en cuenta dos pasos fundamentales. 1.- debemos saber si la lista esta vacia es decir si el primer nodo y el ltimo son iguales a null, si es asi debemos crear un nodo. 2.- el segundo paso seria saber si la lista contiene por lo menos un nodo, y si contiene insertamos, eliminamos o modificamos un nodo dependiendo donde seria, ya sea en la parte posterior, al frente o en una posicin x de la lista.

LISTA DOBLE CIRCULAR

Las listas enlazadas simples tienen la desventaja de no poder recorrer los elementos de una lista de ltimo al primer nodo eficientemente. Existen aplicaciones en las cuales esta operacin se repite con mucha frecuencia, para tal propsito podemos utilizar las lista doble circular. Sin embargo tienen un costo de adicionar un espacio de memoria en cada nodo el cual apunta al nodo anterior. Un nodo de una lista doble circular puede ser considerado como un registro con tres campos: un campo informacin y dos campos de enlaces. Ahora la clase Nodo quedara con dos enlace uno siguiente y uno anterior.

Listas Doblemente Enlazadas

Una lista doblemente enlazada es una lista lineal en la que cada elemento tiene dos enlaces, uno al elemento siguiente y otro al elemento anterior. Esto permite recorrer la lista en cualquier direccin.

Donde p =^Nodolista (apunta al sgte. nodo de la lista) Donde q =^Nodolista (apunta nodo anterior de la lista) Definicin de tipo Lista Doblemente enlazada Type puntero = ^NodoLista NodoLista = Record info: AlgunTipo; siguiente: puntero; anterior: puntero; End; Las operaciones sobre una lista doblemente enlazada se realizan sin ninguna dificultad. Sin embargo, casi siempre es mucho ms fcil la manipulacin de las mismas, cuando se aade un elemento de cabeza y existe un doble enlace entre el ltimo elemento y el primero. Esta estructura recibe el nombre de lista circular doblemente enlazada. Listas Mltiplemente Enlazadas Este tipo de listas contiene ms de dos enlaces por nodo, los que tienen la posibilidad de apuntar a ms de dos listas enlazadas. Vista grfica de un nodo p p Dato p p

Donde p=^nodo Intenta construir su definicin de tipo considerando la vista grfica. Type _________________________ _________________________ _________________________ _________________________ _________________________ _________________________ End; Operaciones Basicas Crear una lista vaca. Recorrer la lista. Buscar un elemento en la lista. Insertar nuevos elementos. Eliminar elementos ya existentes. Crear una lista Inicio:=NIL; (*Inicializar Lista*) Recorrer la Lista p:=inicio; (*El puntero p es ubicado al principio de la lista*) while p<>NIL do begin write(p^.info); (*Se vaca todo el contenido de la lista por pantalla*) p:=p^sgte; end; Bsqueda de un Elemento (*Del nodo con info = x*) p:=inicio;Encontrado:=FALSE; while (p<>NIL) and (NOT ENCONTRADO) do begin if p^.info = x then ENCONTRADO:=TRUE; p:=p^sgte; end; busqueda:= p Esta funcin devuelve un puntero a la primera ocurrencia de nodo con campo info = x o en su defecto apuntando a NIL. Incorporar Elementos (* Antes del nodo apuntado por inicio*, estrategia LIFO) new(p); p^.sgte:=inicio; inicio:= p; (* En otro punto de la lista, antes de nodo con info=x y con el puntero p ubicado antes del punto de insercin*) begin new(t); t^.sgte:=p^.sgte;

p^.sgte:=t; end; (* Despus del ultimo elemento*, estrategia FIFO) p:=inicio; while (p^.sgte<>NIL) do begin p:=p^sgte; (*Ubica a p en el ltimo nodo*) end; new(t); t^.sgte:=p^.sgte; end; Eliminar Elementos Existentes (*Nodo con info=x*) Busqueda(p);(*Deja el puntero p un nodo antes del que ser eliminado*) t:= p^.sgte; p^.sgte:= t^.sgte; dispose(t);

(*Verificar si est vaca o llena*) EstaVaca:= (Inicio=NIL); EstaLlena:= (sizeof(nodo)>MAXAVAIL); Esta funcin devuelve un TRUE o un FALSE dependiendo del valor de verdad de cada expresin RECURSIVIDAD Tcnica que permite definir un procedimiento o funcin en trminos de s mismo, en otras palabras, se dice que un subprograma es recursivo si para cumplir su labor realiza una llamada a s mismo dentro del cdigo. Del latn: recurre- = volver (back)+ currere = a ejecutar (to run) Caractersticas - Cara en trminos de tiempo de ejecucin, debido a los sucesivos empilamientos de variables y direcciones de retorno. - En ciertos casos reemplaza a los ciclos repetitivos debido a su caracter sinttico. Soportada slo por lenguajes que manejan asignacin dinmica de memoria.

ESTRUCTURA DE DATOS DINAMICAS NO LINEALES

RBOLES Es una estructura de datos no lineal que posee raz, ramas y hojas, tcnicamente constituye un grafo finito y sin ciclos. Un rbol define ciertos niveles jerrquicos precedidos por la raz (1er. nivel), en donde las hojas constituyen el nivel ms bajo. Componentes

Raz: Nodo que constituye la nica entrada a la estructura (por ello es necesario tener un puntero sobre l). Ramas o Arcos: Conexin entre dos nodos del rbol que representa una relacin de jerarqua. Hojas: Nodo sin hijos. Caractersticas Nivel o profundidad de un nodo: Longitud del camino para ir desde la raz al nodo. Por definicin la raz est en el nivel 0. Por ejemplo: profundidad(Y)=2, profundidad(raz)=0, profundidad(rbol)= profundidad(hoja ms profunda).

hoja. Por Altura(X)=1, Grado de nodo: Grado de

Altura de un nodo: Longitud del camino ms largo desde el nodo a una ejemplo: Altura(Y)=0, Altura(arbol)=Altura(raz)=profundidad(rbol) Cantidad de hijos de un nodo cualquiera. rbol: Cantidad mxima de hijos posibles de asociar a un nodo del rbol

Clasificacin Segn Nmero de Hijos. Segn Estructura de Niveles Arbol completo: Es un rbol binario en el cual cada nodo es una hoja o posee exactamente 2 hijos. Arbol lleno: Es un rbol binario con hojas en a lo ms dos niveles adyacentes l-1 y l, en las cuales los nodos terminales se encuentran ubicados en las posiciones de ms a la izquierda del rbol.

Si un rbol binario es completo, necesariamente es lleno Segn Funcionalidad

Arbol binario de bsqueda (ABB) Arbol binario de expresin Arboles Binarios de Bsqueda Definicin de un ABB Un rbol binario de bsqueda es un rbol ordenado. Las ramas de cada nodo estn ordenadas de acuerdo con las siguientes reglas: para todo nodo X, las claves ubicadas en el subrbol izquierdo son menores que la clave de X, y todas las claves del subrbol derecho de X son mayores que la clave de X. Un rbol de estas caractersticas permite determinar si una clave determinada existe o no, de manera muy simple. Por ejemplo, si observamos la siguiente figura, localizar la clave 12 es aplicar la definicin de rbol de bsqueda, esto es, si la clave buscada es menor que la clave del nodo en el que estamos, se recorrer el subrbol izquierdo o de lo contrario el subrbol derecho. Este proceso contina hasta encontrar la clave o hasta llegar a un subrbol vaco cuya raz tiene un valor NIL.

Operaciones Bsicas Crear un ABB vaco. Insertar nuevos elementos al ABB. Eliminar elementos ya existentes. Recorrer el ABB. Definamos en primer lugar la estructura que soportar a este rbol: TYPE TipoPuntero = ^TipoNodoABB; TipoNodoABB = RECORD info : TipoInfo; izquierdo : TipoPuntero; derecho: TipoPuntero; End; Crear un ABB vaco. Procedure InicializaArbol(var RaizArbol: TipoPuntero); Begin RaizArbol := NIL; End; Insertar nuevos elementos al ABB. Procedure Insertar_arbol_binario( var Raizarbol: TipoPuntero;InfoNodo: TipoInfo); Var NuevoNodo: TipoPuntero; (*puntero para nodo nuevo*) Ptr, Anterior:TipoPuntero; (* usado para buscar en el ABB*) ClaveNueva: TipoClave;(* clave del nuevo nodo a insertar*) BEGIN (* Crear un nuevo nodo*)

New(NuevoNodo); NuevoNodo^.izquierdo:= NIL; NuevoNodo^.derecho:= NIL; NuevoNodo^.info:= InfoNodo; (* Buscar el lugar de insercin*) ptr: = RaizArbol; Anterior: = NIL; While ptr <> NIL Do begin anterior : = ptr; if ptr^.info.clave > ClaveNueva then ptr := ptr^.izquierdo else ptr := ptr^.derecho end; if anterior = NIL then raizarbol = NuevoNodo else if anterior^.info.clave > ClaveNueva then anterior^.izquierdo: = Nuevonodo else anterior^.derecho: = Nuevonodo END; Eliminar elementos ya existentes. (a)Eliminacin de un nodo hoja slo consiste en anular el puntero de su nodo padre (b)Eliminacin de un nodo con un hijo, es necesario reasignar el puntero del padre hacia el hijo. (c)Eliminacin de un nodo con dos hijos : Reemplazar el nodo que deseamos suprimir con el nodo de valor ms prximo al valor del nodo suprimido. As ser posible hacer el reemplazo por "El mayor ms cercano" o "El menor ms cercano", dependiendo de qu subrbol sea escogido el nodo. Procedure Suprimir (Var RaizArbol: TipoPuntero;ValorClave: TipoClave); (* Suprime el valor que contiene ValorClave del rbol, apuntado por RaizArbol, supondremos que este nodo existe en el rbol*) Var ptr, anterior: TipoPuntero; BEGIN ptr := RaizArbol; anterior:= NIL; While ptr ^.info.clave<> ValorClave Do begin anterior : = ptr; if ptr^.info.clave > ValorClave then ptr := ptr^.izquierdo else ptr := ptr^.derecho end; (* Suprimir nodo apuntado por ptr*, anterior apunta al padre de este nodo*) SuprimirNodo(RazArbol, ptr, Anterior) END; Procedure SuprimirNodo (Var RazArbol : Tipo_Puntero; ptr, anterior: Tipo_ Puntero); (* Suprime el nodo apuntado por Ptr sobre el rbol binario con puntero RaizArbol, Anterior es un puntero al nodo padre ( NIL si el nodo a suprimir es el nodo Raiz)*) Var

temp: Tipo_Puntero; BEGIN (*Caso b.1 Supresin de una hoja*) if(ptr^.derecho = NIL) AND (ptr^.izquierdo = NIL) then IF Anterior = NIL then (*Nodo(ptr) es el ltimo en el rbol) RaizArbol:= NIL else if anterior^.derecho = Ptr then anterior^.derecho : = NIL else anterior^.izquierdo: = NIL else (* Caso b.3 supresin de nodo con dos hijos*) if(ptr^.derecho <> NIL) AND (ptr^.izquierdo <> NIL) then begin (* Encontrar el valor para reemplazar, valor ms prximo al eliminado*) anterior: = ptr; temp := ptr^.izquierdo; While temp^.derecho<> NIL Do begin anterior:= temp; temp : = temp^.derecho end; (* Copiar la informacin a reemplazar en el nodo*) ptr^.info:= temp^.info; if anterior = Ptr then anterior^.izquierdo:= temp^.izquierdo else anterior^.derecho:= temp^.izquierdo; ptr:= temp; end else (* Caso b.2 Nodo con un hijo*) (* Inicializa uno de los campos punteros de nodo (anterior) dependiendo si el nodo que se est suprimiendo tiene un hijo a la derecha o izquierda*) if ptr^.derecho <>NIL then (* Hay un hijo derecho*) if anterior = NIL then RaizArbol:= Ptr^.derecho else if anterior^.derecho=ptr then anterior^.derecho := ptr^.derecho else anterior^.izquierdo := ptr^.derecho else(* hay un hijo izquierdo*) if anterior = NIL then RaizArbol:= Ptr^.izquierdo else if anterior^.derecho=ptr then anterior^.derecho := ptr^.izquierdo else anterior^.izquierdo := ptr^.izquierdo; dispose (ptr); END; ----------------------------------------------------------------------- Recorrer un ABB( extensible a cualquier rbol binario)

Procedure InOrden (ptr: Tipo_puntero); Begin (* CASO BASE: SI PTR ES nil, no hacer nada*) if Ptr <>NIL then begin(* Caso general*) InOrden(ptr^.izquierdo); writeln(ptr^.info); InOrden(ptr^.derecho); end End; Procedure Preorden(ptr: Tipo_puntero); Begin (* CASO BASE: SI PTR ES nil, no hacer nada*) if Ptr <>NIL then begin(* Caso general*) writeln(ptr^.info); PreOrden(ptr^.izquierdo); PreOrden(ptr^.derecho); end End; Procedure PostOrden (ptr: Tipo_puntero); Begin (* CASO BASE: SI PTR ES nil, no hacer nada*) if Ptr <>NIL then begin(* Caso general*) PostOrden(ptr^.izquierdo); PostOrden(ptr^.derecho); writeln(ptr^.info); end End;

GRAFOS

Un grafo G es un par (V(G), A(G)), donde V(G) es un conjunto no vaco de elementos llamados vrtices, y A(G) es una familia finita de pares no ordenados de elementos de V(G) llamados aristas. Se permite la posibilidad de aristas mltiples en el grafo, ms de una arista con el mismo par de vrtices como origen y destino. Se permite la existencia de aristas bucles, con inicio y destino el mismo vrtice DEFINICIONES FUNDAMENTALES Bucle: Toda arista de la forma (v,v) Vrtices adyacentes: se dice que 2 vrtices son adyacentes si estn unidos por una arista. Aristas adyacentes :se dice que 2 aristas son adyacentes cuando tiene un vrtice en comn

DEFINICIONES FUNDAMENTALES

Se dice que un vrtice es aislado si no es adyacente a ningn otro vrtice. Se dice que un grafo es simple si no tiene bucles aristas mltiples Tipos de Grafos a) Grafo Regular: Si G=(V,A), de grado n, si todos sus vrtices tiene grado n. b) Grafo dirigido o dgrafo: Es un par G=(V,A), consistente en un conjunto finito no vaco V, cuyos miembros se llaman vrtices y una familia finita A de pares ordenados de vrtices a cuyos extremos llamaremos arista arcos. Representacin de Grafos

1.

Matriz de adyacencia

2. 3.

Matriz de incidencia Listas

Matriz de adyacenciaSea un grafo G=(V,A), con n- vrtices {v1, v2, v3, ,vn}, su matriz de adyacencia es la matriz de orden nxn, M(G)=(aij), donde aij es el nmero de aristas que unen los vrtices vi y vj Exploracin e Grafos : Recorridos 1. 2. Recorrido en profundidad. Recorrido en anchura.

Recorrido en profundidad

CONCLUSIONES:
Una de las tareas ms complejas e importantes que lleva a cabo el sistema operativo es la de administrar la memoria. Todos los mtodos aqu presentados, suponen que para ejecutar un proceso es necesario tenerlo completamente en memoria principal, ya sea en espacios contiguos o no. La paginacin es un esquema similar al de las particiones estticas, con la ventaja de que un proceso puede ser cargado en ms de una particin y en espacios de memoria no contiguos, lo que reduce la fragmentacin interna a la que se produce en la ltima pgina. La segmentacin es un esquema similar al de las particiones dinmicas con ventajas similares a la paginacin. Tanto en las particiones estticas, como en la paginacin, es necesario determinar el tamao que tendrn los bloques de memoria.

FUENTES CONSULTADAS:
http://www.emagister.com/curso-aprende-programar/estructuras-datos-arreglos http://wwwtemarioestructuradedatos.blogspot.mx/p/estructura-de-datos-dinamicasy.html http://webdiis.unizar.es/asignaturas/EDA/?p=857 http://trinisoft.blogspot.mx/2011/04/estructuras-de-datos-estaticas.html http://recursotec.latinowebs.com/lecciones/c/source/capitulo15-2.htm http://www.google.com.mx/url?sa=t&rct=j&q=&esrc=s&frm=1&source=web&cd=3&v ed=0CDIQFjAC&url=http%3A%2F%2Fwww.itescam.edu.mx%2Fprincipal%2Fsylabus% 2Ffpdb%2Frecursos%2Fr76012.PPT&ei=qW1vUIHMMcSlqQHF3oGYDw&usg=AFQjCNEw qM7CZNwJ9GNFb_t6ryO7DKkAUg Adems utilice informacin de unos pdf.