Estructura de Datos

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD ESCUELA DE CIENCIAS BSICAS TECNOLOGA E INGENIERA CONTENIDO DIDCTICO DEL CURSO: 301305
5 ESTRUCTURA DE DATOS
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA

ESCUELA DE CIENCIAS BSICAS TECNOLOGA E INGENIERA PROGRAMA INGENIERA DE SISTEMAS
301305 ESTRUCTURA DE DATOS HERMES MOSQUERA ANGULO (Director Nacional)
CARLOS ROBERTO ROJAS Acreditador
POPAYAN Enero de 2011
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD ESCUELA DE CIENCIAS BSICAS TECNOLOGA E INGENIERA CONTENIDO DIDCTICO DEL CURSO: 301305 ESTRUCTURA DE DATOS
INDICE DE CONTENIDO
UNIDAD 1. MEMORIA DINMICA....13 CAPITULO 1: APUNTADORES ........................................................................... 15 Leccin 1: Conceptos bsicos de apuntadores .................................................. 15 Leccin 2: Variables Automticas y Apuntadores .............................................. 18 Leccin 3: Apuntadores y Cadenas ................................................................... 21 Leccin 4: Paso de Arreglos Como Parmetros ................................................ 23 Leccin 5: Apuntadores a Apuntadores ............................................................. 27 CAPITULO 2: GESTIN DINMICA DE MEMORIA ............................................ 31 Leccin 6: Conceptos Bsicos de Memoria ....................................................... 31 Leccin 7: Tipos de datos comunes ................................................................... 32 Leccin 8: Tipos de Variables ............................................................................ 35 Leccin 9: Variables Dinmicas ......................................................................... 36 Leccin 10: Asignar y Liberar Espacios de Memoria ......................................... 37 CAPITULO 3: OPERADORES Y FUNCIONES EN LA GESTIN DE MEMORIA .............................................................................................................................. 40 Leccin 11: Operadores New y Delete............................................................... 40 Leccin 12: Ms acerca de la Implementacin de New y Delete ....................... 44 Leccin 13: Funciones Malloc() y Free() ............................................................ 47 Leccin 14: Aplicacin a la asignacin de memoria con Malloc() y Free() ......... 48 Leccin 15: Otras funciones para asignar memoria dinmica ............................ 50
UNIDAD 2. ESTRUCTURAS DE DATOS LINEALES....56 CAPITULO 4: PILAS ............................................................................................ 59 Leccin 1: Conceptos bsicos de pilas .............................................................. 59 Leccin 2: Operaciones realizadas con pilas ..................................................... 60 Leccin 3: Operaciones bsicas con pilas paso a paso ..................................... 62 Leccin 4: Anlisis del cdigo propuesto para implementar una pila ................. 70 Leccin 5: Aplicacin de las estructuras lineales tipo pilas ................................ 75 CAPITULO 5: COLAS .......................................................................................... 82 Leccin 6: Conceptos bsicos de colas ............................................................. 82 Leccin 7: Operaciones bsicas con colas ........................................................ 84 Leccin 8: Implementacin de las Colas por medio de Punteros ....................... 87 Leccin 9: Implementacin del cdigo completo de la cola ............................... 90 Leccin 10: Aplicacin de una cola en un entorno real planificador de citas ..... 93 CAPITULO 6: LISTAS .......................................................................................... 97 Leccin 11: Concepto bsicos de Listas ............................................................ 97 Leccin 12: Listas enlazadas ............................................................................. 99 Leccin 13: Ms a cerca de listas enlazadas ................................................... 105 Leccin 14: Listas doblemente enlazadas ....................................................... 109 Leccin 15: Listas circulares ............................................................................ 117 UNIDAD 3. ESTRUCTURAS DE DATOS NO LINEALES......125 CAPITULO 7: RBOLES ................................................................................... 131 Leccin 1: Teora general de rboles .............................................................. 131 Leccin 2: Otros conceptos de la teora general de rboles ........................... 132 Leccin 3: rbol completo ................................................................................ 133
Leccin 4: Estructura para la creacin de un rbol de orden tres .................... 134 Leccin 5. Introduccin al Modo Grfico de C++ ............................................. 136 CAPITULO 8: RBOLES BINARIOS ................................................................. 142 Leccin 6: Conceptualizacin de Arboles Binarios........................................... 142 Leccin 7: Clasificacin de los rboles binarios ............................................. 1477 Leccin 8: Formas de Recorrer un rbol Binario ............................................. 149 Leccin 9: bol binario de bsqueda (ABB) ..................................................... 154 Leccin 10: Operaciones en ABB .................................................................... 157 CAPITULO 3: GRAFOS...................................................................................... 176 Leccin 11: Conceptos bsicos de grafos ........................................................ 176 Leccin 12: Grafo no dirigido ........................................................................... 178 Leccin 13: Representacin de los grafos ..................................................... 1800 Leccin 14: Representacin mediante listas de Adyacencia ......................... 1833 Leccin 15: Exploracin de grafos ................................................................. 1855
LISTADO DE TABLAS
Tabla 1.30 Tabla 2.31
LISTADO DE GRFICOS Y FIGURAS Figura 1 Salida en pantallade progra1.cpp ............................................................ 17 Figura 2 Salida en pantalla de progra2.cpp ........................................................... 19 Figura 3 Salida en pantalla de progra3.cpp ........................................................... 21 Figura 4 Salida en pantalla de progra4.cpp ........................................................... 22 Figura 5 Salida en pantalla de progra5.cpp ........................................................... 23 Figura 6 Salida en pantalla de progra6.cpp ........................................................... 25 Figura 7 Salida en pantalla de progra7.cpp ........................................................... 26 Figura 8 Salida en pantalla de progra8.cpp ........................................................... 27 Figura 9 Salida en pantalla de progra9.cpp ........................................................... 28 Figura 10 Salida en pantalla de progra10.cpp ....................................................... 30 Figura 11 Salida en pantalla de progra11.cpp ....................................................... 34 Figura 12 Salida en pantalla de progra12.cpp ....................................................... 36 Figura 13Salida en pantalla de progra13.cpp ........................................................ 37 Figura 14 Salida en pantalla de progra14.cpp ....................................................... 39 Figura 15 Salida en pantalla de progra15.cpp ....................................................... 42 Figura 16 Salida en pantalla de progra16.cpp ....................................................... 45 Figura 17 Salida en pantalla de progra17.cpp ....................................................... 46 Figura 18 Salida en pantalla de progra18.cpp ....................................................... 48 Figura 19 Salida en pantalla de progra19.cpp ....................................................... 50 Figura 20 Representacin grfica de una pila de monedas .................................. 60 Figura 21 Entrada y salida de elementos de una pila ............................................ 61
Figura 22 Declaracin de la estructura pila ........................................................... 64 Figura 23 Men de opciones de la pila .................................................................. 66 Figura 24 Definicin de la funcin insertar() .......................................................... 66 Figura 25 La funcin insertar() en el case 1 .......................................................... 67 Figura 26 Instrucciones de la funcin insertar() ..................................................... 68 Figura 27 Vista de la definicin de las funciones insertar, visualizar y extraer ...... 70 Figura 28 Salida en pantalla de Progra21.cpp ...................................................... 75 Figura 29 Salida en pantalla de Progra22.cpp ...................................................... 78 Figura 30 Salida en pantalla de Progra23.cpp ...................................................... 81 Figura 31 Representacin grfica de una cola de personas. ................................ 83 Figura 32 Representacin grfica de una cola ...................................................... 84 Figura 33 Salida en pantalla de progra24.............................................................. 87 Figura 34 Salida en pantalla de Progra25.cpp ...................................................... 93 Figura 35 Salida en pantalla de progra26.cpp ....................................................... 96 Figura 36 Representacin grfica de una lista contigua ........................................ 99 Figura 37 Representacin grfica de listas enlazadas ........................................ 100 Figura 38 Salida en pantalla de Progra27.cpp .................................................... 105 Figura 39 Salida en pantalla de progra28.cpp ..................................................... 106 Figura 40 Salida en pantalla de progra29.cpp ..................................................... 108 Figura 41 Representacin grfica de una lista doblemente enlazada ................. 109 Figura 42 Salida en pantalla de progra30.cpp ..................................................... 117 Figura 43 Representacin grfica de una Lista Circular ...................................... 118 Figura 44 Lista circular simplemente enlazada ................................................... 119 Figura 45 Lista circular doblemente enlazada ..................................................... 119
Figura 46 Primer nodo de la lista circular ............................................................ 120 Figura 47 Insercin del segundo nodo ................................................................ 120 Figura 48 Nuevo nodo insertado en la lista circular ............................................. 121 Figura 49 Salida en pantalla de progra31.cpp ..................................................... 124 Figura 50 Representacin grfica de rboles ...................................................... 132 Figura 51 Interfaz grfica del compilador Borland C++ 5.5. ................................ 138 Figura 52 Activacin de las libreras Grficas .......... Error! Marcador no definido. Figura 53 Configuracin de directorio para BGI .................................................. 139 Figura 54 Interfaz de directorios de C++. ............................................................ 139 Figura 55 Inclusin de la ruta C:\TC\BGI ............................................................. 140 Figura 56 Salida en pantalla de progra32 Modo grafico de C++. ........................ 141 Figura 57 Estructura de un rbol binario ............................................................. 142 Figura 58 Representacin grfica de un rbol binario ......................................... 143 Figura 59 Representacin grfica del subrbol izquierdo.................................... 143 Figura 60 Representacin grfica del subrbol derecho ..................................... 144 Figura 61 Representacin grfica de un nodo padre .......................................... 144 Figura 62 Representacin grfica de un nodo hoja ............................................. 145 Figura 63 Camino del rbol ................................................................................. 145 Figura 64 Longitud del rbol binario .................................................................... 146 Figura 65 Nivel del rbol...................................................................................... 147 Figura 66 Representacin grfica de un rbol binario completo. ........................ 147 Figura 67 Representacin grfica de rbol binario igual ..................................... 148 Figura 68 Representacin grfica de rboles semejantes................................... 149 Figura 69 Representacin grfica de rboles isomorfos ..................................... 149
Figura 70 Recorrido del rbol binario en preorden ............................................. 150 Figura 71 Resultado del recorrido en preorden del rbol .................................... 150 Figura 72 Representacin grfica del recorrido en Inorden................................. 152 Figura 73 Recorrido en Postorden del rbol binario. ........................................... 153 Figura 74 rbol binario como aplicacin a los tres recorridos ............................. 154 Figura 75 Borrado de un nodo rama con intercambio de nodo hoja .................... 157 Figura 76 Representacin grfica de un rbol binario de bsqueda ................... 158 Figura 77 Borrado de un nodo rama con intercambio de nodo rama .................. 158 Figura 78 Intercambio de un nodo rama con intercambio de nodo rama ............ 159 Figura 79 Salida en pantalla de progra34............................................................ 167 Figura 80 Representacin grfica de los grafos .................................................. 177 Figura 81 Representacin grfica de un grfo dirigido ........................................ 178 Figura 82 Representacin grfica de un grafo no dirigido ................................... 178 Figura 83 Representacin grfica de grafos etiquetados .................................... 179 Figura 84 Representacin grfica de la longitud del camino de un grafo ............ 179 Figura 85 Grafo dirigido ...................................................................................... 181 Figura 86 Representacin grfica de la matriz de adyacencia ............................ 181 Figura 87 Representacin grfica de un grafo por lista de adyacencia ............... 183 Figura 88 Representacin grafica de un grafo .................................................... 186
ASPECTOS DE PROPIEDAD INTELECTUAL Y VERSIONAMIENTO
La versin uno del presente mdulo fue diseado en el ao 2004 por el Ing. Ivn Arturo Lpez, docente de la UNAD, ubicado en el CEAD de Popayn, el Ing. Lpez es Ingeniero de Sistemas, Especialista en Pedagoga Para el Desarrollo del Aprendizaje Autnomo y Magister en Educacin y TICs, se ha desempeado como Tutor y Docente de la UNAD desde el ao 2000. La versin dos del presente mdulo fue desarrollada por el Ing. Hermes Mosquera Angulo en el ao 2007, quien ha sido Tutor de la UNAD en el CEAD Popayn, desde el ao 2006, se desempea actualmente como Director del cuso a nivel nacional desde el ao 2007.
INTRODUCCIN
El curso de estructura de datos cobra vital importancia en la aplicacin de la programacin estructurada y al cual se le puede sacar el mximo provecho, puesto que se requiere que los estudiantes que abordan el curso tengan los conocimientos previos, tratados en los cursos anteriores de Algoritmos e Introduccin a la programacin. Estructura de datos es un curso metodolgico de compuesto de tres unidades didcticas en donde se combina la parte terica con la parte prctica, con el desarrollo de pequeos programas de aplicacin basados en entornos reales. En ese sentido, el curso inicia con la primera unidad en la que se tratan temas como los fundamentos bsicos de apuntadores, asignacin dinmica de memoria al igual que los operadores y funciones para la gestin de memoria. Se propone una metodologa de trabajo en la que se invita al estudiante a realizar una lectura detallada de cada leccin con el propsito de profundizar en la conceptualizacin; posteriormente en la mayora de temas se proponen cdigos fuente completos que sirven como ejemplos de programas de aplicacin a la temtica tratada. Estos cdigos pueden ser llevados a cualquier compilador de C++, para el curso se propone el compilador Turbo C++ 3.0 para plataformas Windows XP y el compilador Borland C++ 5.5 para plataformas Windows Vista y Windows 7, por su facilidad de uso amigabilidad y preconfiguracin, para el caso de plataforma Linux puede emplearse el editor que trae por defecto para programas C++. Los compiladores pueden ser descargados directamente del sitio https://sites.google.com/site/hhmosquera/file-cabinet. En la segunda unidad se profundiza en temas relacionados con las estructuras de datos lineales, donde se abordan los temas como pilas, colas, listas, desarrollados con apuntadores, brindando al estudiante los fundamentos y competencias necesarias para brindar soluciones en programacin a entornos reales. Final en la tercera unidad se contina con la profundizacin y aplicacin de las estructura de datos no lineales se podra hablar de estructuras jerrquicas con los temas de rboles y grafos los cuales inducen al estudiante a trabajar con el modo grfico de C++ como acercamiento a la programacin orientada a objetos. En el curso se incluyen ejercicios prcticos, realizados por diferentes autores, sitios web como referencia y una amplia bibliografa externa y tambin existente en la biblioteca virtual de la UNAD, que sin duda llevara al estudiante a un aprendizaje autnomo y significativo.
UNIDAD 1
Nombre de la Unidad MEMORIA DINMICA La memoria del computador es un recurso invaluable de mucha importancia en el procesamiento de informacin, que requiere darle un buen uso por parte de los programadores con el fin de optimizar espacios en memoria. Por esta razn, en esta, la primera unidad del curso, se hace una introduccin a conceptos bsicos como apuntadores, asignacin dinmica de memoria y operadores como new y delete propios de C++ y funciones como Malloc() y free(), propios de C. Igualmente estn implcitas diferentes estrategias de pensamiento de orden superior que el estudiante ir descubriendo gracias al apoyo permanente del tutor, quien en es el mediador del proceso de aprendizaje. En el transcurso de la unidad, se desarrollan actividades que buscan determinar el grado de apropiacin del conocimiento, basados en los tres momentos: reconocimiento, profundizacin y transferencia, sin dejar al lado el desarrollo del componente prctico que tiene como finalidad afianzar los conocimientos en pro de lograr la competencia del curso. La memoria de la computadora es un recurso invaluable y finito en cuanto asu capacidad, con muchos usos. Para el caso de los programadores de computados, solo uno y es guardar informacin. Por tal razn es importante darle un buen manejo a la memoria y esto se puede hacer cuando en el desarrollo de programas informticos, se hace una buena definicin de las de variables de acuerdo al tipo de informacin que se requiera almacena. Los datos significan la informacin con la cual trabaja un programa. En este mundo competitivo quien tiene la informacin tiene el poder. Ya sea que el programa est trabajando con una lista de direcciones, monitoreando la bolsa de valores, manejando el presupuesto nacional o 12
Introduccin
Justificacin
cualquier otra situacin, la informacin (nombres, precios de acciones, gastos) es guardada en la RAM de la computadora mientras el programa se est ejecutando. Entra aqu el concepto de la gestin dinmica de memoria y los apuntadores, como un tipo de variables que permiten por medio de funciones y operadores asignar y liberar memoria dinmicamente en tiempo de ejecucin, es decir mientras el programa est en marcha. Profundizar en la conceptualizacin del tipo de datos y los bytes requeridos que se manejan en el leguaje C++ contribuye al buen desarrollo de programas informticos. Conocer y aplicar el funcionamiento de las estructuras de datos lineales. Profundizar en aspectos bsicos en apuntadores y la asignacin dinmica de memoria. Intencionalidades Formativas Diferenciar Conceptualmente el uso y la aplicacin de las variables estticas y las variables dinmicas. Aplicar la conceptualizacin de los operadores y funciones para el manejo de la memoria dinmica. Realizar aplicaciones en lenguaje C++ utilizando estructuras dinmicas de memoria APUNTADORES Conceptos bsicos de apuntadores Variables Automticas y Apuntadores Apuntadores y Cadenas Paso de Arreglos Como Parmetros Apuntadores a Apuntadores GESTIN DINMICA DE MEMORIA Conceptos Bsicos de Memoria Tipos de datos comunes Tipos de Variables Variables Dinmicas Asignar y Liberar Espacios de Memoria OPERADORES Y FUNCIONES PARA LA GESTIN DE MEMORIA Operadores New y Delete Ms acerca de la Implementacin de New y Delete 13
Captulo 1 Leccin 1 Leccin 2 Leccin 3 Leccin 4 Leccin 5 Captulo 2 Leccin 6 Leccin 7 Leccin 8 Leccin 9 Leccin 10 Captulo 3 Leccin 11 Leccin 12
Leccin 13 Leccin 14 Leccin 15
Funciones Malloc() y Free() Aplicacin a la asignacin de memoria con Malloc() y Free() Otras funciones para asignar memoria dinmica
14
CAPITULO 1: APUNTADORES Introduccin En el presente capitulo se aborda la temtica de los apuntadores y la aplicabilidad que tienen en el campo de la programacin estructurada. Los apuntadores son un tipo especial de variables que guardan direcciones de otras variables. en los lenguajes de programacin de C y C++. Proporcionan mucha utilidad al programador ya que permiten accesar y manipular datos de tal manera que no es posible realizarse en otros lenguajes llamados de alto nivel. Tambien son utiles para pasarle parametros a las funciones de tal modo que les permiten modificar y regresar valores a la rutina o funcin que hace el llamado. Cuando se utilizan incorrectamente, pueden producir algunos problemas de esrtabilidad en el sistema o tambin pueden presentar fallas en el programa en ejecucin. De igualmanera se llevarn a cabo aplicaciones pequeas de programas codificados en C++ como aplicacin al uso de los apuntadores y a las operaciones que se pueden llevar a cabo. Cada uno de estos programas presenta en una figura la salida en pantalla, es decir todos estn previamente compilados y depurados. Leccin 1: Conceptos bsicos de apuntadores Antes de definir qu es un puntero, veremos primero cmo se almacenan los datos en un computador. La memoria de un computador est compuesta por unidades bsicas llamadas bits. Cada bit slo puede tomar dos valores, normalmente denominados alto y bajo, 1 y 0. Pero trabajar con bits no es prctico, por eso se agrupan. Cada grupo de 8 bits forma un byte u octeto. En realidad el microprocesador, y por lo tanto nuestro programa, slo puede manejar directamente bytes o grupos de dos o cuatro bytes. Para acceder a los bits hay que acceder antes a los bytes. Cada byte tiene una direccin, llamada normalmente direccin de memoria. Definicin de Apuntadores Un apuntador es una variable, que almacena como contenido una direccin de memoria, de otra variable a la que apunta, dicha direccin representa el lugar donde se almacena un dato. Los apuntadores tienen un tipo de dato especfico y 15
solo pueden apuntar a espacios de memoria con datos del mismo tipo. Por supuesto, a partir de esa direccin de memoria puede haber cualquier tipo de objeto: un char, un int, un float, un array, una estructura, una funcin u otro puntero. Sern los programadores los responsables de decidir ese contenido. Con los apuntadores es posible manipular estructuras de datos o asignar memoria dinmica. Los apuntadores son una de las herramientas ms poderosas con que cuenta el Lenguaje C++. Desafortunadamente, muchos programadores han creado el mito de que el estudio de los apuntadores es muy complicado, lo cual ha desarrollado una fobia entre quienes se inician en el estudio de las estructuras dinmicas en lenguaje C++. Declaracin de apuntadores Los apuntadores son variables automticas cuyos valores representan direcciones de memoria correspondientes a otras variables del mismo tipo a las que apunta. La sintaxis para la declaracin de una variable de tipo apuntador es la siguiente: tipo * identificador ; Donde, tipo hace referencia al tipo de datos de C++ como int, char, float, entre otros e identificador, hace referencia al nombre de la variable apuntador. Ejemplo: int *apunt; se declara el apuntador apunt de tipo entero. Se dice que: "apunt va a apuntar a variables de tipo int" donde apunt es el nombre del apuntador y (*) es el operador de indireccin que indica que apunt es un apuntador. En el ejemplo anterior, puede decirse que: *apunt se refiere al objeto apuntado por apunt. apunt es un apuntador a objetos de tipo int Observe que el operador de indireccin utiliza el mismo smbolo que el operador de multiplicacin. En este caso el asterisco le indica al sistema que se define una variable apuntador. Ejemplos: int *x; char *y; double *r, *s; x es un apuntador de tipo entero. y es un apuntador de tipo carcter. r y s son apuntadores de tipo real doble precisin.
16
Operadores para trabajar apuntadores Los operadores utilizados para trabajar variables apuntadores son el ( * ) asterisco llamado operador de indireccin, y el ( & ) ampersand, llamado operador de direccin. * toma su operando como una direccin de memoria y retorna la informacin almacenada en ese lugar. & devuelve la direccin de memoria de su operando.
Aplicacin prctica del uso de apuntadores Progra1.cpp #include <iostream.h> #include <conio.h> void main(void) { int x, y; //Define x, y variables enteras. int *p, *q; //Define p y q variables tipo apuntador. p = &x; //asigna a p la direccin de x. (p apunta a x). q = &y; //asigna a q la direccin de y. (q apunta a y). *p = 10; //almacena en x el valor 10. *q = *p * 2; //almacena en y el valor de x multiplicado por 2 (20). y = y + *p; //a la variable y le suma el valor en x (20+10). cout<<El contenido de X es: <<*p <\n; //imprime el contenido de x (10). cout<<,El contenido de Y es: <<*q; //imprime el contenido de y (30). getch(); } El resultado de la impresin en pantalla de Progra1 se puede visualizar en la grfica 1. Figura 1 Salida en pantallade progra1.cpp
17
Leccin 2: Variables Automticas y Apuntadores Las variables automticas se crean en tiempo de compilacin y se destruyen al terminar la ejecucin del mdulo donde fueron declaradas. Aunque no es estrictamente necesario, se pueden manejar las variables automticas por medio de apuntadores, se puede apreciar en el siguiente ejemplo. Implementacin de variables automticas Progra2.cpp #include <iostream.h> #include <conio.h> void main() { int automatica ; int *apunt ; automatica = 100 ; apunt = &automatica ; clrscr(); cout << "VALOR=" << automatica << " \n"; *apunt= 200 ; cout << "VALOR=" << automatica << " \n"; getch(); } Anlisis de Progr2.cpp Progra2.cpp es el nombre del programa con su respectiva extensin .cpp. En la lnea 1 y 2, se incluyen las librera o archivos de cabecera necesarios para el buen funcionamiento del programa y soportar la sintaxis del lenguaje, se pueden incluir otras segn se requieran. En la lnea 3, se define la funcin principal main() de tipo void, lo que indica que no retorna ningn valor. En la lnea 4, se da apertura a la funcin por medio de una llave, dentro de ella van las instrucciones del programa y se cierra cuando finalizan las instrucciones o el cdigo. En la lnea 5, se declara la variable llamada automtica que es de tipo entero. En la lnea 6, se declara el apuntador llamado apunt, de tipo entero, que apunta a objetos de tipo int. 18
En la lnea 7, Se asigna el valor 100 a la variable automatica. En la lnea 8, se asigna a apunt la direccin de memoria de la variable automtica En la lnea 9, se limpia pantalla por medio de la funcin clrscr() para que las salidas en pantalla de anteriores ejecuciones sigan mostrndose. En la lnea 10, se muestra la salida en pantalla del valor de la variable automtica que es 100. En la lnea 11, se asigna el valor 200 al objeto apuntado por apunt. Es decir a la variable automtica. En la lnea 12, se muestra en pantalla el nuevo valor que tom la variable automtica que para este caso es 200. En la lnea 13 se introduce la funcin getch() que hace la ejecucin del programa termine solo cuando se presione una tecla. Finalmente en la lnea 14 se cierra la llave indicando que terminan las instrucciones de la funcin principal. El resultado de Progra2.cpp se puede observar en la figura 2, que se muestra a continuacin. Figura 2 Salida en pantalla de progra2.cpp
Ms acerca de apuntadores Un apuntador es una variable que solo puede contener un valor a la vez, por lo que solo puede apuntar a un objeto al mismo tiempo. Por otro lado, una variable cualquiera puede ser apuntada (referenciada) por varios apuntadores, ya que su direccin de memoria puede ser almacenada en distintas variables a la vez. 19
Al declarar un apuntador, se est especificando el tipo de variable al que va a apuntar. Por ejemplo, no podr declararse un apuntador a objetos de tipo int y despus intentar utilizarlo para apuntar a objetos de tipo float. Cuando se desee manejar un apuntador a cualquier tipo de objeto, se puede declarar de tipo void, como en: void *apuntadores ; Aplicacin de apuntadores de tipo void En el siguiente listado se muestra un ejemplo de aplicacin de un apuntador de tipo void. Progra3.cpp #include <iostream.h> #include <conio.h> void main() { int entero=1 ; float decimal=1.1 ; void *apvarios=&entero; // apvarios APUNTA A entero *(int *)apvarios="1" // ASIGNA 1 AL OBJETO APUNTADO POR apvarios cout << "El valor de entero es: "<<entero<<"\n" ; apvarios=&decimal ; // apvarios APUNTA A decimal *(float *)apvarios="1.1" // ASIGNA 1.1 AL OBJETO APUNTADO POR apvarios cout << "El valor de decimal es: "<<decimal ; getch(); } Anlisis de Progra3.cpp Analicemos la siguiente instruccin: *(int *)apvarios = 1 ; En donde: Apvarios, es un apuntador de tipo void. (int *)apvarios est forzando a que apvarios apunte a objetos de tipo int. *(int *)apvarios se refiere a un objeto de tipo entero apuntado por apvarios. En la grafica 1.1 se obtiene la salida en pantalla de Progr3.cpp.
20
Figura 3 Salida en pantalla de progra3.cpp
Leccin 3: Apuntadores y Cadenas Una cadena se puede definir como un arreglo de caracteres cuyo ltimo elemento es el caracter nulo. Utilizando la nomenclatura de arreglos, podemos declarar un arreglo llamado nombre[ ] de tipo carcter asignndole la frase COMERCIO: char nombre[ ] = "COMERCIO" ; La misma asignacin puede realizarse por medio de apuntadores, como se observa en el siguiente enunciado. char *nombre = "COMERCIO" ; En este caso se define a nombre como un apuntador que apunta a datos de tipo char, al que se le asigna la frase COMERCIO. Aplicacin de apuntadores a cadenas Progra4.cpp #include <iostream.h> #include <conio.h> #include <stdio.h> void main() { char *nombre = "COMERCIO" ; clrscr(); gotoxy(30,12); cout<< "!! HOLA, " ; puts(nombre); gotoxy(43,12); cout << " !!"; getch(); }
21
En la figura 4, se visualiza la salida en pantalla de progra4.cpp, se presentan dos funciones objeto de anlisis. La funcin gotoxy() posiciona el mensaje o la salida en pantalla !! HOLA en las coordenadas x=30 y y=12. La funcin puts() es propia para el manejo de cadena de caracteres, muestra en pantalla el contenido de la variable nombre.
Arreglos de apuntadores Los apuntadores pueden manejarse en un arreglo, de tal forma que: char nombres[ ][5] = { "HUGO", "PACO", "LUIS" } ; es la declaracin de un arreglo de cadenas, con asignacin de valores iniciales. Su equivalente en notacin de apuntadores es: char *nombres[ ] = { "HUGO", "PACO", "LUIS" } ; En el que se declara un arreglo de apuntadores con tres valores asignados. El programa completo para el manejo de este ejemplo se presenta en el Progra5.cpp. Implementacin de arreglos de apuntadores Progra5.cpp #include <iostream.h> #include <conio.h> #include <string.h> void main() { char *nombres[ ] = { "HUGO", "PACO", "LUIS" } ; 22
char invitado[11]; int bandera; clrscr(); gotoxy(20,5); cout << "CUAL ES SU NOMBRE ?: " ; gotoxy(50,10); cin>> invitado ; gotoxy(20,7); for( int x = 0 ; x <3 ; x++ ) if(strcmp(invitado, nombres[x])== 0) bandera=0; if(bandera== 0) cout << "!! SIGA AMIGO ES BIENVENIDO " << invitado << " !!"; else cout << "!! USTED NO ES BIENVENIDO, " << invitado << " !!"; getch();
En la figura 5, se visualiza el resultado de la salida en pantalla de Progra5.cpp, en el que se incluye la librera <string.h> necesaria para el manejo de cadena de caracteres con las funciones de comparar cadena (strcmp); la cual compara el nombre solicitado por teclado con los nombres asignados al arreglo previamente, en caso de que coincida muestra el primer mensaje de bienvenida, de lo contrario muestra el segundo mensaje.
Leccin 4: Paso de Arreglos Como Parmetros Un arreglo puede pasarse como parmetro a una funcin. Si tuviera que pasarse por valor un arreglo muy grande, sera un desperdicio de memoria y que es funcin de los programadores optimizar este recurso. En el Lenguaje C++, el paso 23
de arreglos se hace por referencia, ya que el nombre del arreglo corresponde a un apuntador al primer elemento del arreglo. Al pasar un parmetro correspondiente a un arreglo, se pasa la direccin del primer elemento, por lo que la funcin invocada puede modificar cualquier elemento del arreglo. El siguiente programa maneja una funcin llamada valor(), la cual recibe como parmetro un arreglo de caracteres. Implementacin de paso de arreglos como parmetros Progra6.cpp #include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> void valor(char *); void main() { char cadena[81]; clrscr(); gotoxy(10,10); cout << "INGRESE UNA FRASE CORTA: "; gets(cadena); gotoxy(10,12); valor(cadena); getch(); } void valor(char arreglo[ ]) { int x=0; while(arreglo[x]) { cout << arreglo[x] ; x++; } } El resultado de la salida en pantalla de progra6.cpp se visualiza en la figura 6, que se muestra a continuacin, en la que un arreglo de caracteres llamado cadena se pasa como parmetros a la funcin llamada valor.
24
Implementacin de la funcin valor() por medio de apuntadores En el siguiente listado se muestra el manejo de la funcin valor(), por medio de apuntadores. Progra7.cpp #include <iostream.h> #include <conio.h> #include <stdio.h> #include <string.h> void valor(char *); void main() { char cadena[81]; clrscr(); gotoxy(10,5); cout << "ESCRIBA UNA CADENA: "; gets(cadena); gotoxy(10,7); valor(cadena); getch(); } void valor(char *apuntador) { while(*apuntador) cout << *apuntador++ ; } Analizando este listado y comparndolo con el progra6.cpp se observa que la diferencia radica en el parmetro de la funcin llamada valor() que par este caso es un apuntador de tipo char que guarda una cadena y para el progra6.cpp es un arreglo de caracteres, que igualmente almacena una cadena y posteriormente 25
despliega el resultado, tal como se puede evidenciar en la figura 7, que se muestra a continuacin. Figura 7 Salida en pantalla de progra7.cpp
Paso de funciones como parmetros Toda funcin tiene asociada una direccin de inicio de cdigo, la cual puede pasarse un apuntador como parmetro cuando se llama o se invoca a otra funcin. He aqu un ejemplo como aplicacin al paso de funciones como parmetros a funciones. Implementacin del paso de funciones como parmetros Progra8.cpp #include <iostream.h> #include <string.h> #include <conio.h> int cmpcad(char*, char*); void compara(char*, char*, int(*)(char*, char*)); void main() { char cadenax[80], cadenay[80]; clrscr(); gotoxy(10,5); cout << "ESCRIBA UNA CADENA : " ; cin>> cadenax; gotoxy(10,7); cout << "ESCRIBA OTRA CADENA : " ; cin>> cadenay; gotoxy(10,9); compara(cadenax, cadenay, cmpcad); gotoxy(1,24); } void compara(char *cadena1, char *cadena2, int (*cmpcad)(char*, char*)) { if(!(*cmpcad)(cadena1,cadena2)) 26
cout << "LAS CADENAS SON IGUALES"; else cout << "LAS CADENAS SON DISTINTAS";
int cmpcad(char *x, char *y) { return(strcmp(x,y)); } El resultado de la compilacin y posterior ejecucin del listado llamado progra8,cpp se conjuga en la salida en pantalla como se muestra en la figura 8. Figura 8 Salida en pantalla de progra8.cpp
Explicando la expresin que puede ser un tanto desconocida del listado anterior, la expresin: int(*cmpcad)(char*, char*). Establece que cmpcad es un apuntador a una funcin, la cual devuelve un valor de tipo entero. Leccin 5: Apuntadores a Apuntadores Tal como se trat al inicio de captulo, un apuntador tambin es una variable. Su direccin puede ser almacenada por otra variable apuntador del mismo tipo, por lo que puede hablarse de un apuntador a un apuntador. Esto puede difundirse para dos o ms variables, como se observa en el ejemplo siguiente de apuntadores a apuntadores.
27
Implementacin de apuntadores a apuntadores Progra9.cpp #include <iostream.h> #include <conio.h> void main() { int x, *a, **b, ***c ; // 1 clrscr(); a = &x ; // 2 *a = 100 ; // 3 b = &a ; // 4 **b += *a ; // 5 c = &b ; // 6 ***c += **b + *a ; // 7 cout << " *a=" << *a << " \n" ; cout << " **b=" << **b << " \n" ; cout << "***c=" << ***c << " \n" ; getch(); } En el listado se analizan tres variables de tipo apuntador que apuntan a objetos de tipo entero, es decir que *a es un apuntador, **b es un apuntador a apuntador y ***c es un apuntador a apuntador a apuntador.
Operaciones con apuntadores Se pueden realizar asignaciones entre punteros. int a = 15; int *p, *q; 28
q = &a; p = q; cout<<p;
/* se asigna la direccin que contiene q a p */ /* imprime la direccin almacenad en p. */
Se pueden operar solamente el +, el -, el ++ y el --. Int p; p = p + 1; p avanza un entero. p = p 2; p retrocede dos enteros. p++; p apunta al siguiente entero. p--; p apunta al entero anterior. Los punteros se pueden comparar. int a; int *b, *c; if (b + n > c) b = b +2;
Como aplicacin a las operaciones que se pueden realizar con apuntadores, se presenta el siguiente cdigo en un programa que emplea los operadores (& y *). Progra10.cpp #include <iostream.h> #include <conio.h> int main() { clrscr(); int a; //a es un puntero int * ap; //ap es un apuntador a un puntero a = 7; ap= & a; //ap toma la direccin de a cout <<"la direccin de a es " <<&a; cout<<" \n el Valor de ap es " << ap; cout <<"\n el valor de a es" <<a; cout<<"\n el valor de *ap es " << *ap; cout<<"\n\n\n Mostrando los valores de * y &" ; cout <<"\n &* ap = " <<&*ap; cout <<"\n *& ap = " << *≈ getch(); return 0; } 29
Anlisis de Progra10.cpp Tal como se observa en la imagen es la salida en pantalla del programa en el que se aprecia la diferencia entre el valor de la variable a que devuelve un valor numrico igual a 7; mientras que la variable ap devuelve la direccin de memoria de a. Figura 10 Salida en pantalla de progra10.cpp
30
CAPITULO 2: GESTIN DINMICA DE MEMORIA Introduccin La gestin dinmica de memoria hace referencia a la forma enque se almacenan los datos en la computadora. Se aborda la temtica relacionada con los tipos de datos que maneja el lenguaje C++ y el nmero de bytes requeridos para almacenar cada tipo de datos, aunque este tema es transparente para el usuario normal de un sistema computacional, si debe ser motivo de preocupacin para los programadores, que estn llamados a hacer buen uso de los recursos tanto fsicos como lgicos. Por otro lado se aborda la temtica relacionada con los tipos de varibles, variables estticas y dinmicas. As como tambin el uso y la aplicabilidad del operador sizeof en la gestin dinmica de memoria. En la memoria del computador se guardan no solo las constantes y variables sin tambin las instrucciones del programa. Cada objeto y cada instruccin en la memoria tienen previamente asignada una direccin nica. Slo se carga el programa principal en la memoria inicialmente. El resto de subprogramas, algoritmos y funciones se va cargando segn se van requiriendo. Leccin 6: Conceptos Bsicos de Memoria Para iniciar este captulo es importante darle un vistazo a la memoria de la computadora. Si usted ya sabe cmo funciona la memoria de la computadora, se puede saltar esta seccin. Sin embargo, si no est seguro, es importante que la lea, le ayudara a comprender mejor ciertos aspectos de la programacin. La computadora usa memoria de acceso aleatorio (RAM) para guardar informacin mientras est en funcionamiento. La RAM se encuentra en circuitos integrados o chips en el interior de la computadora. La RAM es voltil, lo que significa que es borrada y reemplazada con nueva informacin tan pronto como se necesita. La volatilidad tambin significa que la RAM recuerda solamente mientras la computadora est encendida, y pierde su informacin cuando se apaga o se reinicia la computadora. Cada computadora tiene una determinada cantidad de RAM instalada. La cantidad de RAM en un sistema se especifica por lo general en Megabytes (Mb) por ejemplo 256 Mb, 512 Mb, en ese orden de ideas se dice que un byte es la unidad 31
de medida fundamental de la memoria de una computadora, de los cuales se obtiene los Kilobytes, Megabytes, Gigabytes, siendo estos los ms usados. Un kilobytes de memoria equivale a 1,024 bytes. Tipo de datos y bytes requeridos en memoria Para darse una idea de que tantos bytes se necesitan para guardar determinados tipos de datos se pone a disposicin la tabla 2.1donde se muestran los espacios requeridos para guardar datos en la memoria del computador. Tabla1: Bytes requeridos para los tipos de datos DATOS La letra X El nmero 100 El nmero 125.12 La frase Aprenda usted mismo Una pgina escrita completamente 1 2 4 21 3000 (Aproximadamente) BYTES REQUERIDOS
La RAM en la computadora est organizada en forma secuencial, un byte tras otro. Cada byte de memoria tiene una direccin nica mediante la cual es identificada, una direccin que tambin lo distingue de todos los otros bytes de la memoria. Las direcciones son asignadas a la memoria en orden, comenzando en 0 y aumentando hasta llegar al lmite de memoria instalada en el sistema. Para ampliar un poco ms la conceptualizacin a cerca de los tipos de datos se define todo el posible rango de valores que una variable puede tomar al momento de ser ejecutada en el programa al igual que en toda la vida til del propio programa.
Leccin 7: Tipos de datos comunes En la tabla 1 se muestran los tipos de datos y el espacio en memoria de cada dato en bytes, sin embargo tambin es posible determinar el tamao en bites para los tipos de datos ms comunes utilizados frecuentemente en C++, tal como se muestra en la Tabla 2: 32
Tabla 2: Otros tipos de datos comunes TIPO DATO unsigned char Char short int unsigned int Int unsigned long Enum Long Float Doubl long doubl Void ESPACIO MEMORIA 8 bits 8 bits 16 bits 32 bits 32 bits 32 bits 16 bits 32 bits 32 bits 64 bits 80 bits sin valor RANGO PERMITIDO 0 a 255 -128 a 127 -32,768 a 32,767 0 a 4,294,967,295 -2,147,483,648 a 2,147,483,647 0 a 4,294,967,295 -2,147,483,648 a 2,147,483,647 -2,147,483,648 a 2,147,483,647 3.4 x 10-38 a 3.4 x 10+38(6 dec) 1.7 x 10-308 a 1.7*10+308(15 dec) 3.4 x 10-4932 a 1.1 x 10+4932
Fuente: http://www.wikilearning.com/tutorial/tutorial_de_c++-tipos_de_datos/9773-4
Es posible realizar una representacin de la Tabla 2 en trminos de programacin para visualizar el tipo de datos y el espacio requerido en memoria presentado en bits como la mnima medida del sistema binario. Tal como se puede ver en el listado siguiente llamado Progra11.cpp. Progra11.cpp #include <iostream.h> #include <conio.h> int main () { cout<<"TIPOS DE DATOS Y TAMANO EN BITS\n\n"; cout<< "El tamano del tipo de dato int es :"<<sizeof(int)*8<<" bits\n"; cout<< "El tamano del tipo de dato short es :"<<sizeof(short)*8<<" bits\n"; cout<< "El tamano del tipo de dato long es :"<<sizeof(long)*8<<" bits\n"; cout<< "El tamano del tipo de dato char es :"<<sizeof(char)*8<<" bits\n"; cout<< "El tamano del tipo de dato float es :"<<sizeof(float)*8<<" bits\n"; cout<< "El tamano del tipo de dato double es:"<<sizeof(double)*8<<" bits\n"; getch(); return 0; } Ya se tiene el cdigo fuente guardado con el nombre de Progra11.cpp, ahora solo resta compilar y ejecutar el cdigo para obtener el siguiente resultado como salida en pantalla. 33
Usos de la Memoria RAM Seguramente con frecuencia alguien se ha planteado la siguiente pregunta Para qu se usa la memoria RAM de la computadora?. Tiene varios usos, pero solamente uno, el almacenamiento de datos, le interesa al programador. Los datos significan la informacin con la cual trabaja un programa. Ya sea que el programa est trabajando con una lista de direcciones, monitoreando la bolsa de valores, manejando un presupuesto, controlando la nmina de una empresa o cualquier otra tarea, la informacin de (nombres, precios de acciones, gastos, salarios) es guardada en la RAM de la computadora mientras el programa est ejecutndose. Hasta el momento, la mayora de los programas se han realizado definiendo variables, sin tener la preocupacin de qu se est realizando internamente en el computador, muchas veces en forma indiscriminada, es decir sin una verdadera depuracin, pero existen ocasiones en que no se sabe cunta memora se requerir para la ejecucin de un determinado programa; por ejemplo, si deseamos realizar un procesador de textos, de entrada no se conoce cul va hacer la longitud del texto. Por eso a veces es necesario poder reservar memoria segn se va necesitando. Adems de esta forma los programas en ejecucin aprovecharn mejor la memoria del computador, usando slo los recursos necesarios. Realmente la utilidad de asignacin dinmica de memoria ser aplicada en gran medida en los captulos relacionados con las estructuras de datos lineales, tema que se trata en la unidad dos. De acurdo a lo anterior se puede identificar dos tipos de variables: estticas y dinmicas para ampliar estos conceptos se invita a revisar la temtica tratada en la Leccin 3.
34
Leccin 8: Tipos de Variables Dependiendo del uso que se le d a las variables por parte del programador en una rutina o tarea especfica, se pueden identificar dos tipos de variables, las variables dinmicas y variables estticas. Variables estticas Las variables estticas tal como se recuerda en los inicios de los fundamentos de programacin, son aquellas que el programador les asigna memoria antes de la ejecucin del programa o de una funcin. Las variables estticas se llaman mediante el nombre de la misma, que ha sido declarada por el programador y su funcin principal dentro de un programa es almacenar informacin dependiendo del tipo de dato con que se haya declarado. Aplicacin de las variables estticas A continuacin se presenta el cdigo fuente de un programa que hace uso de las variables estticas. Progra12.cpp #include <stdio.h> #include <iostream.h> #include <stdlib.h> #include <conio.h> int priNumero; /* Las variables */ int segNumero; int suma; void main() { clrscr(); priNumero = 136; segNumero = 369; suma = priNumero + segNumero; cout<<"La suma es " <<suma; getch(); } Anlisis de Progra12.cpp En el cdigo del programa se hace uso de tres variables de tipo entero que son variables estticas ellas son: priNumero que se le asigna el valor 136, mientras 35
que a la variable segNumero se le asigna el valor 369, de igual manera a la variable suma calcula el resultado de sumar el valor de las dos variables. Aunque se trata de un programa sencillo de entender que solo muestra la suma de dos variables estticas, vale la pena poner a disposicin la salida en pantalla tal como se presenta a lo largo del curso. Figura 12 Salida en pantalla de progra12.cpp
Leccin 9: Variables Dinmicas Las variables dinmicas deben su nombre al hecho de que pueden ser creadas y destruidas durante el tiempo de ejecucin de un mdulo. Para el manejo de variables dinmicas se hace indispensable la utilizacin de apuntadores, as como de funciones especiales para la asignacin y liberacin de la memoria correspondiente a dichas variables. Aplicacin de las variables dinmicas A continuacin se presenta el cdigo fuente completo de un programa que hace uso de las variables dinmicas. Progra13.cpp #include <iostream.h> #include <conio.h> void main() { int x, *a, **b, ***c ; // 1 clrscr(); a = &x ; // 2 *a = 100 ; // 3
36
b = &a ; // 4 **b += *a ; // 5 c = &b ; // 6 ***c += **b + *a ; // 7 cout << " *a=" << *a << " \n" ; cout << " **b=" << **b << " \n" ; cout << "***c=" << ***c << " \n" ; getch();
Anlisis de Progra13.cpp En el listado del progra13.cpp se declaran tres variables de tipo apuntador que apuntan a datos de tipo entero, ellas son, *a, **b y **c. El apuntador a almacena la direccin de la variable x, luego a al apuntador a se le asigna el valor de 100, lo que indica que x vale 100, mientras que **b precedida de dos asteriscos indica que es una variable que apunta a un apuntador, para este caso b guarda la direccin de el puntero a, y ***c es un apuntador a apuntador a apuntador, lo cual puede simplificarse en que c guarda la direccin de b. El resultado del listado Progra13.cpp se puede visualizar en la Figura 13. Figura 13Salida en pantalla de progra13.cpp
Leccin 10: Asignar y Liberar Espacios de Memoria En el lenguaje C existen entre otras las funciones Malloc() y Free() para la asignacin y liberacin de memoria dinmicamente respectivamente. Cuando se ejecuta un programa, el sistema operativo reserva una zona de memoria para el cdigo o instrucciones del programa y otra para las variables que se usan durante la ejecucin. A menudo estas zonas son la misma zona, es lo que se llama memoria local. Tambin hay otras zonas de memoria, como la pila, que se usa, entre otras cosas, para intercambiar datos entre funciones. El resto, la 37
memoria que no se usa por ningn programa es lo que se conoce como "heap" o montn. Cuando el programador use memoria dinmica, normalmente usar memoria del montn, y no se llama as porque sea de peor calidad, sino porque suele haber realmente un montn de memoria de este tipo disponible para ser usado en la medida que se requiera. Profundizando un poco en la asignacin dinmica, se encuentra el operador sizeof, el cual determina el tamao en bytes que se requiere en la asignacin dinmica de memoria, ya sea por medio de los operadores New y Delete, o por las funciones Malloc y Free, de un arreglo o de cualquier otro tipo de datos, Ejemplo utilizar el operador sizeof en una funcin con el propsito de determinar el tamao en bytes de un parmetro. Aplicacin del operador sizeof. En el siguiente listado se evidencia la aplicacin y uso del operador sizeof en cada variable el cual devuelve el nmero de bytes dependiendo del tipo de variable. Implementacin del uso de sizeof Progra14.cpp #include <iostream.h> #include <conio.h> void main() { char P; short R; int I; long L; float F; double D; long double LD; clrscr(); gotoxy(1,2); cout<<"valores utilizando sizeof para cada una de la varibles \n\n"; cout<<" variable P = " <<sizeof P; cout<<"\t tipo char = " <<sizeof (char); cout<<"\n variable R = " <<sizeof R; cout<<"\t tipo short = " <<sizeof (short); cout<<"\n variable I = " <<sizeof I; cout<<"\t tipo int = " <<sizeof (int); cout<<"\n variable L = " <<sizeof L; cout<<"\t tipo int = " <<sizeof (long);
38
cout<<"\n variable F = " <<sizeof I; cout<<"\t tipo float = " <<sizeof (float); cout<<"\n variable D = " <<sizeof D; cout<<"\t tipo double = " <<sizeof (double); cout<<"\n variable LD = " <<sizeof LD; cout<<"\t tipo int = " <<sizeof (long double); cout<<"\n variable I = " <<sizeof I; cout<<"\t tipo int = " <<sizeof (int); getch();
Anlisis de Progra14.cpp En la siguiente grfica se visualiza el resultado del progra13.cpp en laque se puede apreciar el resultado almacenado en la variable y los bytes requeridos para cada tipo de dato. Figura 14 Salida en pantalla de progra14.cpp
39
CAPITULO 3: OPERADORES Y FUNCIONES EN LA GESTIN DE MEMORIA
Introduccin En el presente captulo se trata la temtica relacionada con los operadores y las funciones utilizadas para la gestin de memoria, en ese sentido se realizan programas como aplicacin a los operadores new y delete propios de C++, al igual que las funciones malloc(), free() y calloc() y realloc() propias de C. Al igual que en cada uno de los captulos, se presentan programas de aplicacin que dan respuesta a al temtica planteada, estos programas estn previamente compilados y depurados para garantizar que el estudiante pueda editarlos analizalos y plantear mejoras que contribuyan a su formacin y al adquisicin de la competencia del curso desarrollada en cada uno de sus captulos. Leccin 11: Operadores New y Delete El lenguaje C++ cuenta con dos operadores preconstruidos, ellos son: New y Delete, por esta razn no se requiere incluir ninguna librera o archivo de cabecera para utilizarlos. El operador New: Realiza una labor parecida a la de la funcin malloc(), asignando un bloque de memoria segn sea requerido. El operador Delete: Libera un bloque de memoria asignada por New en tiempo de ejecucin, de manera semejante a como lo hace la funcin free(). La sintaxis para el uso del operador new es: Apuntador = new tipo_de_dato; Este operador hace una peticin al sistema operativo para que se le asigne un espacio en memoria, con el tamao acorde al tipo de datos (vale la pena recordar la funcin sizeof), si este espacio est disponible, la operacin regresa la direccin real que se otorga, en caso de no haber espacio regresa el valor de NULL (0), La sintaxis para el uso del operador delete es: delete apuntador; 40
La ejecucin de este operador provoca que se libere espacio, dejando como valor indefinido, es decir el sistema operativo lo considera como memoria disponible. Hay una regla de oro utilizada por algunos autores, se refiere a que cuando se usa memoria dinmica, toda la memoria que se reserve durante el programa hay que liberarla antes de salir del programa. No seguir esta regla es una actitud muy irresponsable, y en la mayor parte de los casos tiene consecuencias desastrosas que atentan con la estabilidad de su sistema. No es bueno fiarse de lo que diga el compilador, de que estas variables se liberan solas al terminar la ejecucin del programa, no siempre puede ser as. Aplicacin de los operadores New y Delete Se presenta un ejemplo como aplicacin de los operadores de C++, utilizados para asignar y liberar memoria dinmicamente. En el listado se declaran las variables index de tipo entero y los apuntadores point1 y point2 ambos de tipo entero. Progra15.cpp # include <iostream.h> # include <conio.h> main() { clrscr(); int index, *point1, *point2; point1 = &index; *point1 = 77; point2 = new int; *point2 = 173; cout <<"SALIDA DE LAS VARIABLES index, *point1 Y *point2\n\n"; cout <<"Los valores son " << index <<" " << *point1 << " "<< *point2 <<'\n'; point1 = new int; point2 = point1; *point1 = 999; cout <<"Los valores son " << index <<" " << *point1 << " "<< *point2 <<'\n'; delete point1; float *float_point1, *float_point2 = new float; float_point1 = new float; *float_point2 = 3.14159; *float_point1 = 2.4 * (*float_point2); delete float_point2; delete float_point1; char *c_point; 41
c_point = new char; delete c_point; c_point = new char [sizeof(int) + 133]; delete c_point; getch(); return 0;
Anlisis de Progra15.cpp El resultado de la ejecucin del listado llamado Progra16.cpp se visualiza en la Figura 15. Figura 15 Salida en pantalla de progra15.cpp
En las primeras lneas del programa, se hace uso de los punteros tal como se hacen tambin en C. point2 ilustra el uso del operador new. Este operador requiere un modificador que debe ser un tipo. La parte new int significa que se crea un nuevo entero en la memoria, y devuelve la localizacin del entero creado. Esta localizacin es asignada a point2. La siguiente lnea asigna 173 al entero al que apunta point2. Es importante distinguir entre point2, la localizacin del entero, y *point2, el entero. El puntero point2 apunta ahora a una variable entera que se ha reservado dinmicamente, y que puede utilizarse de igual forma que se haca en C. Como ejemplo, se imprime el valor al que apunta. A continuacin, se reserva memoria para una nueva variable, y point2 se refiere a la misma variable reservada dinmicamente a la que apunta point1. En este caso, la referencia a la variable a la que point2 apuntaba previamente se ha perdido, y nunca podr ser utilizada o su memoria liberada. Slo cuando se vuelva al sistema operativo se liberar la memoria que ocupaba. Por tanto, no debe utilizarse. 42
Ya que el puntero point1 en s no ha cambiado, apunta realmente al dato original. Este dato podra referenciarse otra vez utilizando point1, pero no es una buena prctica de programacin, ya que no hay garanta de lo que el sistema pueda hacer con el puntero o el dato. La localizacin del dato queda libre para ser reservada en una llamada subsiguiente, y ser pronto reutilizada en cualquier programa. Ya que el operador delete est definido para no hacer nada si se le pasa un valor NULL, se puede liberar la memoria ocupada por un dato al que apunta un puntero NULL, ya que realmente no se est haciendo nada. El operador delete slo puede utilizarse para liberar memoria reservada con el operador new. Si se usa delete con cualquier otro tipo de dato, la operacin no est definida, y por tanto nada sucede. En el programa tambin declaramos algunas variables reales, y se realizan operaciones similares a las anteriores. De nuevo esto ilustra que en C++ las variables no tienen que ser declaradas al comienzo de cada bloque. Una declaracin es una sentencia ejecutable y puede entonces aparecer en cualquier lugar en la lista de sentencias ejecutables. Finalmente, ya que el operador new requiere un tipo para determinar el tamao de un bloque dinmicamente reservado, se muestra cmo reservar un bloque de tamao arbitrario. Esto es posible utilizando la construccin de las ltimas lneas del programa, donde un bloque de 37 caracteres de tamao (37 bytes) es reservado. Un bloque de 133 bytes mayor que el tamao de un entero se reserva posteriormente. Por tanto, el operador new se puede utilizar con la misma flexibilidad de la funcin malloc() de C. Cuando los datos reservados dinmicamente son borrados con delete, todava quedan en memoria. Si repetimos la instruccin cout inmediatamente despus de utilizar delete, veremos que todava se conservan los valores. Si la repetimos de nuevo antes de dejar el programa, cuando el espacio que ocupaban debe haber sido sobrescrito, veremos que ya no es as. Incluso aunque el compilador nos d los nmeros correctos, no es una buena prctica pensar que esos datos estn ah todava, porque en un programa dinmico largo la memoria se usar continuadamente. Las funciones estndar utilizadas en C para manejo dinmico de memoria, malloc(), calloc() y free(), tambin se pueden utilizar en C++ de la misma forma que en C. Los operadores new y delete no deben mezclarse con estas funciones, ya que los resultados pueden ser impredecibles. Si se est partiendo de cdigo C, lo mejor es continuar utilizando las funciones en las nuevas lneas de programa. Si no es as, se deben utilizar los nuevos 43
operadores, ya que se han construido como parte del lenguaje en s, ms que aadirse, y por tanto son ms eficientes1.
Cuando se utiliza new para reservar memoria para un vector, el tamao del vector se sita entre corchetes, siguiendo al tipo: int *intvector; intvector = new int [20]; y se libera: delete [ ] intvector;
Leccin 12: Ms acerca de la Implementacin de New y Delete El siguiente muestra un ejemplo de aplicacin de los operadores new y delete. Progra16.cpp #include <iostream.h> //1 #include <conio.h> //2 void main() //3 { //4 clrscr(); //5 int *numero; //6 numero = new int ; //7 //8 *numero = 10 ; cout <<"VALOR DE NUMERO\n\n"; //9 cout <<"El resultado de numero es:" <<*numero ; delete numero ; //11 getch(); //12 } //13
//10
En el listado llamado Progra16.cpp, se supone que la reservacin ser exitosa porque existe espacio suficiente en el montculo. Del listado se puede analizar lo siguiente: En las lneas 1 y 2 se incluyen las libreras requeridas para la ejecucin del programa sin errores de compilacin y ejecucin. En la lnea 3 se incluye la funcin principal main() la cual no retorna ningn valor por estar declarada como tipo void. La lnea 4 se incluye la llave que da apertura a la funcin principal.
Tomado de: http://www.pablin.com.ar/computer/cursos/c1/allocate.html
44
La lnea 5 se incluye la funcin clrscr() utilizada para limpiar pantalla de ejecuciones anteriores del programa. En la lnea 6 se declara un puntero llamado numero y es de tipo entero. En la lnea 7 se reserva un bloque de memoria dinmica de 2 bytes para manejarlo por medio de numero. En la lnea 8 Asigna el valor 10 al objeto apuntado por numero. En la lnea 9 se despliega un mensaje en pantalla. En la lnea 10 se despliega el contenido del objeto apuntado por numero. La lnea 11, libera el espacio de memoria asignado o manejado por numero. En la lnea 12 se incluye la funcin getch(), la cual hace una parada del programa a la espera que se presione una tecla para finalizar la ejecucin del programa. Finalmente la lnea 13, se incluye la llave que cierra las instrucciones que hacen parte de la funcin principal. El resultado de la salida en pantalla se puede visualizar en la Figura16. Figura 16 Salida en pantalla de progra16.cpp
Pero quin asegura que el espacio requerido por new est disponible?. Para controlar esta situacin y evitar un mensaje de error por parte del sistema en tiempo de ejecucin, en el listado siguiente se propone una nueva versin del programa. Implementacin de New para verificacin de memoria Progra17.cpp #include <iostream.h> #include <stdlib.h> #include <conio.h> void main() { int *numero; 45
if((numero = new int)==NULL) { cout << "NO hay espacio suficiente\n"; exit(1); } *numero=20 ; cout <<"Resultado\n\n"; cout << "El resultado de numero es:"<<*numero ; delete numero ; getch();
El resultado en pantalla de Progra17.cpp se puede visualizar en la Figura 17.
Otro caso a considerar es la reserva de memoria con el operador new para un arreglo, un ejemplo sera la reserva de memoria para crear un arreglo de 25 elementos de tipo double, en el montculo, puede declararse como: Double *numero; numero = new double[25]; De igual manera en su forma equivalente se tiene: double *numero = new double[25]; En este ejemplo, se est declarando a nmero como un apuntador a variables dinmicas de tipo doble; al tiempo que se le asigna el valor retornado por new. El valor retornado por new es la direccin del inicio de un bloque de memoria del tamao requerido para almacenar 25 elementos de tipo double. En caso de que el montculo no disponga del espacio requerido, new retorna el valor NULL (nulo).
46
Leccin 13: Funciones Malloc() y Free() La funcin Malloc() Es una de las funciones de asignacin de memoria propias del lenguaje de programacin C (acrnimo de memory allocation). Cuando se usa malloc () se pasa la cantidad de bytes de memoria que se necesita. Malloc () encuentra y reserva un bloque de menora del tamao pedido y regresa la direccin del primer byte del bloque. No hay de qu preocuparse sobre que parte de memoria se usa, ya que esto es manejado automticamente. La funcin malloc () regresa una direccin, y su tipo de retorno es un apuntador a tipo void. Por qu void?. Un apuntador a tipo void es compatible con todos los tipos de datos. Como la memoria asignada por malloc () puede ser usada para guardar cualquiera de los tipos de datos de C, es adecuado el tipo de retorno void. La funcin Free() Al igual que malloc(), free() es una funcin del lenguaje de programacin C, utilizado para liberar la memoria asignada por malloc (). Al usar la funcin free () se debe tener en cuenta la regla de oro explicada en el apartado del operador delete toda la memoria que se reserve durante el programa hay que liberarla antes de salir del programa Al usar las funciones malloc () y free () se debe incluir el archivo de cabecera o librera STDLIB.H. Ejemplos de aplicacin Ejemplo 1 Asigna memoria para un arreglo de 50 enteros Int *numero; numero = (int * ) malloc (50 * sizeof (int)); Ejemplo 2 Asigna memoria para un arreglo de 10 valores float float *numero; numero = (float * ) malloc (10 * sizeof (float));
47
Leccin 14: Aplicacin a la asignacin de memoria con Malloc() y Free() Una Buena aplicacin de las funciones utilizadas para la gestin dinmica de memoria se puede visualizar en el siguiente listado llamado Progra18.cpp. Progra18.cpp #include <iostream.h> #include <conio.h> #include <stdlib.h> #include <stdio.h> int main() { clrscr(); int *p=NULL; int nbytes=100; p=(int *)malloc(nbytes); if(p==NULL) { cout<<"Insuficiente espacio en memoria\n"; return -1; } cout<< "Bytes Reservados\n\n"; cout<<"Se han asignado " <<nbytes <<" bytes de memoria\n"; free(p); getch(); } La salida en pantalla de Progra18.cpp se puede visualizar en la Figura 18 que se muestra a continuacin. Figura 18 Salida en pantalla de progra18.cpp
El resultado del programa muestra un mensaje en pantalla confirmando que se realiz la asignacin dinmica de memoria de 100 bytes con xito. A continuacin se presenta otro ejemplo de aplicacin de la asignacin dinmica de memoria utilizando las funciones malloc () y free (), con un ingrediente adicional 48
el uso de una estructura llamada persona, la cual permita almacenar el registro de datos de una persona, dos tipos de datos diferentes, un dato de tipo carcter que almacena el nombre de la persona y otro dato de tipo entero para almacenar la edad. He aqu la implementacin del programa completo. Implementacin del uso de Malloc() y Free() Progra19.cpp // Listado de libreras o archives de cabecera #include<iostream.h> #include<stdlib.h> #include<conio.h> // Definicin de la funcin principal void main() { clrscr(); int n, i; // Definicin de la estructura persona struct persona { char nombre[20]; int edad; }; // Definicin del puntero p de tipo persona utilizado para reservar memoria persona *p; cout<<"PROGRAMA QUE GUARDA EL REGISTRO DE PERSONAS"<<"\n"; cout<<"\nNUMERO DE PERSONAS A INGRESAR : "; cin>>n; // Reserva de memoria dinmica a travs de malloc () p =(persona *)malloc(sizeof(persona)); // El ciclo for usado para la entrada de los datos de la persona for(i=1;i<=n;i++) { cout<<"\nDIGITE EL NOMBRE " << i <<" : "; cin>>p[i].nombre; cout<<"DIGITE LA EDAD : "; cin>>p[i].edad; cout<<"\n"; 49
} clrscr(); cout<<"LISTADO DE PERSONAS REGISTRADAS "<<"\n"; // El ciclo for usado para la impresin o visulizacin de los datos registrados for(i=1;i<=n;i++) { cout<<" NOMBRE : "<<p[i].nombre<<"\n"; cout<<" EDAD : "<<p[i].edad<<"\n\n"; } getch(); // La funcin free () libera la memoria asignada al apuntador p free (p); }
Resultado en pantalla del Progra19.cpp La siguiente imagen muestra el resultado de en pantalla que registra el nombre y la edad de 3 tres personas. Figura 19 Salida en pantalla de progra19.cpp
Leccin 15: Otras funciones para asignar memoria dinmica Aparte de la funcin Malloc() tratada en la seccin anterior, utilizada para la gestin dinmica de memoria, existen dos funciones adicionales para reservar memoria, ellas son: calloc() y realloc(). La Funcione Calloc() A continuacin se presentan el prototipo para la definicin de la funcin Calloc(). 50
void *calloc(size_t nmemb, size_t size); Cuando se usa la funcin malloc() la memoria no es inicializada (a cero) o borrada. Si se quiere inicializar la memoria entonces se puede usar la funcin calloc. La funcin calloc es computacionalmente un poco ms cara pero, ocasionalmente, ms conveniente que malloc. Se debe observar tambin la diferencia de sintaxis entre calloc y malloc, ya que calloc toma el nmero de elementos deseados (nmemb) y el tamao del elemento (size), como dos argumentos individuales. Por lo tanto para asignar a 100 elementos enteros que estn inicializados a cero se puede hacer: int *ip; ip = (int *) calloc(100, sizeof(int) ); La Funcin Realloc() Esta funcin intenta cambiar el tamao de un bloque de memoria previamente asignado. El nuevo tamao puede ser ms grande o ms pequeo. Si el bloque se hace ms grande, entonces el contenido anterior permanece sin cambios y la memoria es agregada al final del bloque. Si el tamao se hace ms pequeo entonces el contenido sobrante permanece sin cambios. El prototipo de definicin para la funcin realloc() es como se presenta a continuacin. void *realloc(void *ptr, size_t size); Si el tamao del bloque original no puede ser redimensionado, entonces realloc intentar asignar un nuevo bloque de memoria y copiar el contenido anterior. Por lo tanto, la funcin devolver un nuevo apuntador (o de valor diferente al anterior), este nuevo valor ser el que deber usarse. Si no puede ser reasignada nueva memoria la funcin realloc devuelve NULL. 2 Si para el ejemplo anterior, se quiere reasignar la memoria a 60 enteros en vez de 100 apuntados por ip, se har; ip = (int *) realloc ( ip, 60*sizeof(int) ); Aplicacin de Calloc void *calloc(size_t nmemb, size_t tamano);
2
Tomado de: http://www.fismat.umich.mx/mn1/manual/node10.html
51
Adjudica espacio para un array de nmemb objetos, cada cual tiene como tamao tamano. El espacio es inicializado a cero todos los bits. La funcin calloc retorna o bien un puntero nulo o bien un puntero al espacio adjudicado. Progra20.cpp #include <stdio.h> #include <stdlib.h> #include <conio.h> int main( void ) { int *numPtr, i; size_t tamano=0; printf( "Introduzca el tamao de la lista: " ); scanf( "%d", &tamano ); puts( "Adjudicamos espacio a la lista (con calloc)." ); numPtr = (int *)calloc( tamano, sizeof(int) ); for( i=0; i<tamano-1; i++ ) printf( "%d, ", numPtr[i] = rand() % 100 + 1 ); printf( "%d\n", numPtr[i] = rand() % 100 + 1 ); numPtr = (int *)realloc( numPtr, tamanyo/=2 ); printf( "Recortamos la lista a la mitad: %d\n", tamano ); for( i=0; i<tamano-1; i++ ) printf( "%d, ", numPtr[i] ); printf( "%d\n", numPtr[i] ); puts( "Liberamos el espacio (con realloc)." ); realloc( numPtr, 0 ); getch(); return 0; } //Fin de la implementacin de la funcin Calloc3
Tomado de: http://www.conclase.net/c/librerias/funcion.php?fun=calloc
52
Actividades de Autoevaluacin de la Unidad 1 Ejercicio 1. Teniendo en cuenta la conceptualizacin y la aplicabilidad en el campo de la programacin frente al uso de las variables estticas y las variables dinmicas, realice un cuadro comparativo de las caractersticas, ventajas y desventajas. Ejercicio 2. Se requiere gestionar cadenas de caracteres, a travs de variables de tipo char, establezca diferencias para la declaracin y definicin de variables estticas y las variables dinmicas (Apuntadores) para este tipo de datos. Ejercicio 3. Determinar las reglas del funcionamiento de los operadores new y delete e identifique las principales diferencias entre la utilizacin de new y delete, frente a la utilizacin de malloc() y free(). Ejercicio 4. Aplicacin de operaciones con apuntadores. Teniendo en cuenta los fundamentos tericos a cerca de las operaciones que se pueden realizar con apuntadores, documente cada lnea de cdigo de los siguientes enunciados. Enunciado 1 int P = 10; int *x, *y; y = &P; x = y; cout<< El resultado de x es : << x ; Enunciado 2 Int punt; punt = punt + 1; punt = punt 2; punt++; punt--; // 1 // 2 // 3 // 4 // 5 No. de Lneas de cdigo // 1 // 2 // 3 // 4 // 5
Ejercicio 5. Analice el siguiente cdigo que es una aplicacin de apuntadores a apuntadores, documente cada una de las 10 lneas de cdigo y exprese el resultado de cada una de las variables. 53
Enunciado 3
No. de Lneas de cdigo
void main() { int m, *h, **s, ***q ; clrscr(); h = &m ; *h = 80 ; s = &h ; **s += *h ; q = &s ; ***q += **s + *h ; cout << " *h=" << *h << " \n" ; cout << " **s=" << **s << " \n" ; cout << "***q=" << ***q << " \n" ; getch(); }
// 1 // 2 // 3 // 4 // 5 // 6 // 7 //8 //9 //10
Ejercicio 6. Implemente un programa usando memoria dinmica con las funciones Malloc() y Free() para que imprima los datos bsicos de dos personas haciendo uso de una estructura. Ejercicio 7. Implementar un programa que asigne memoria con new y delete, para un arreglo de estructuras, el cual desea llevar los registros bsicos de 5 mascotas, como: raza, nombre, color y edad Ingresados por teclado, adems de determinar en tiempo de ejecucin el tamao del arreglo a utilizar. Ejercicio 8. Implemente un programa que imprima los datos bsicos de un automvil (Marca, modelo, color, cilindraje) usando una estructura llamada automvil y incluya variables de tipo apuntador.
54
Fuentes Documentales de la Unidad 1 AGUILAR, Luis (2003). Fundamentos de programacin, algoritmos, estructura de datos y Objetos, Tercera edicin. Espaa: McGRAW-HILL. AGUILAR, Luis (200). Programacin en C++, Algoritmos, estructura de datos y Objetos. Espaa: McGRAW-HILL. AGUILAR, Luis (2003). Fundamentos de programacin, algoritmos, estructura de datos y Objetos Tercera edicin. Espaa: McGRAW-HILL. AGUILAR Luis, ZAHONERO Martnez (2004). Algoritmos y Estructuras de Datos. Una perspectiva en C. Madrid-Espaa: McGraw-Hill. BROOKSHEAR, J. Glenn (1995). Introduccin a las ciencias de la Computacin (Cuarta Edicn). Edicin Espaola: Addison-Wesley Iberoamericana. DEYTEL Y DEYTEL(1999). Como programa C++. Segunda Edicin. Mexico D.F: Prentice Hall. McGRAW-HILL. FARREL, Joyce (2000). Introduccin a la programacin lgica y diseo. Mexico D.F: Thomson. KENNETH C, Louden (2004). Lenguajes de programacin. Segunda edicin. MexicoD.F: Thomson. ESPINOZA, David (2004). Curso bsico de Algoritmia. Consultado en Octubre, 24 de 2008 en http://www.geocities.com/david_ees/Algoritmia/curso.htm. MENDEZ, Justo (2004). Las tendencias en los lenguajes de programacin. Consultado en Noviembre de 2008 en http://www.ilustrados.com/publicaciones/EpZVVEZpyEdFpAKxjH.php. CACERES, Abdiel (2005). Estructuras de datos en C++. Consultado en Febrero 25 de 2009 en http://computacion.cs.cinvestav.mx/~acaceres/courses/estDatosCPP/ ALGORITMIA.NET (2003). Grafos. Consultado en Noviembre de 2008 en http://www.algoritmia.net/articles.php?id=18. FUENTES, Arenas (1997). Reserva dinmica de Memoria. Consultado en Octubre 23 de 2008 en http://www.pablin.com.ar/computer/cursos/c1/allocate.html. 55
TEJADA, Hector (2005). Asignacin dinmica de Memoria y estructuras dinmicas. Consultado en Octubre 23 de 2008 en http://www.fismat.umich.mx/mn1/manual/node10.html. DAVINSON, Steven (2001). Funcin Calloc Ansi C. Consultado en Junio 23 de 2009 en http://www.conclase.net/c/librerias/funcion.php?fun=calloc. SOTO, Lauro (2005). Manejo de Memoria. Consultado en Junio 23 de 2009 en http://www.programacionfacil.com/estructura_de_datos/manejo_de_memoria.
56
UNIDAD 2
Nombre Unidad
de
la ESTRUCTURA DE DATOS LINEALES La presente Unidad se ha dividido en tres captulos donde se aborda ampliamente la conceptualizacin de las estructura de datos lineales, con aplicacin de programas completos, codificados en C++. Para la compilacin de los programas, puede utilizarse cualquier compilador de C++ de los muchos que estn disponibles como es el caso de Las versiones de Borland C++ 3.0, Borland C++ 4.5, Borland C++ 5.02 y Borland C++ 5.5 y DevC++ en cualquiera de sus versiones, esto solo por mencionar algunas. En el captulo 4 se trata el tema de Pilas, profundizando en las operaciones que se pueden realizar con implementaciones de programas en C++. En el captulo 5 se trata el tema de Colas con sus operaciones e implementacin de programas codificados en C++. Finalmente en el captulo 6 se aborda el tema de las listas, tipos de listas y sus operaciones con implementacin de programas codificados en C++. Al final de la unidad, se plantean algunas actividades complementarias que buscan determinar el grado de apropiacin del conocimiento, basados en los tres momentos: Reconocimiento, Profundizacin y transferencia, que pueden dar soporte valorativo al logro de las competencias del curso. El contenido de esta unidad tiene gran aplicabilidad en situaciones reales cotidianas que pueden ser representadas por medio de la pilas, colas y listas, es muy comn y fcil de llevar a la realidad, por ejemplo una lista de clientes, proveedores, una pila de productos, una cola para realizar una consignacin en un banco o un servidor para el manejo de impresiones, al igual que lo vemos representado a diario en el uso de cualquier herramienta de Oficce con la opcin deshacer, al eliminar la ltima orden recibida. 57
Introduccin
Justificacin
Conocer y aplicar el funcionamiento de las estructuras de datos lineales. Determinar las tcnicas y estructuras utilizadas, desde las perspectivas de las aplicaciones de software, para resolver problemas mediante la utilizacin de las estructuras lineales Intencionalidades pilas, colas y listas. Formativas Profundizar en la fundamentacin terica y prctica de las estructuras dinmicas lineales Pilas, Colas y Listas. Implementar el uso de las estructuras dinmicas lineales dando solucin a situaciones reales. Pilas Conceptos bsicos de pilas Operaciones realizadas con pilas Operaciones bsicas con pilas paso a paso Anlisis del cdigo propuesto para implementar una pila Aplicacin de las estructuras lineales tipo pilas Colas Conceptos bsicos de colas Operaciones bsicas con colas Implementacin de las Colas por medio de Punteros Implementacin del cdigo completo de la cola Aplicacin de una cola en un entorno real planificador de citas Listas Concepto bsicos de Listas Listas enlazadas Ms a cerca de listas enlazadas Listas doblemente enlazadas Listas circulares
Captulo 4 Leccin 1 Leccin 2 Leccin 3 Leccin 4 Leccin 5 Captulo 5 Leccin 6 Leccin 7 Leccin 8 Leccin 9 Leccin 10 Captulo 6 Leccin 11 Leccin 12 Leccin 13 Leccin 14 Leccin 15
58
CAPITULO 4: PILAS Introduccin Las pilas son un tipo de estructura de datos de tipo lineal condicionadas donde las inserciones y eleminaciones se realizan por un mismo extremo. Se tratan los temas relacionados con los conceptos bsicos de las pilas, las operaciones que se pueden realizar con las pilas, todo conjugado en programas de aplicacin, implementados con apuntadores, al igual que en los anteriores captulos, cada uno de los programas aqu presentados, estn previamente compilados y depurados de tal manera que se mustra la salida en pantalla de cada uno. Lo anterior garantiza al estudiante que puede guiarse en el cdigo fuente para hacerle modificaciones y proponer soluciones a entornos reales. Leccin 1: Conceptos bsicos de pilas La pila se considera un grupo ordenado de elementos porque estos estn clasificados de acuerdo al tiempo en que estn residiendo en la pila, el elemento que se elimina de la cabeza es siempre el que lleve menos tiempo en ella. En resumen una pila es una lista en la cual los elementos solo pueden ser insertados y eliminados por un extremo de ella, este extremo es llamado la cima. De esta forma los elementos son eliminados en forma contraria a como fueron insertados. Definicin de una Pila Una pila llamada stack (en ingls) se puede definir como un tipo especial de lista lineal condicionada, en la que las inserciones y el borrado de nuevos elementos se realizan slo por un extremo, que se denomina cima o tope top (en ingls). La pila es una estructura con numerosas analogas en la vida real: pila de platos, una pila de monedas, una pila de camisas, una pila de animales, etc. Como se muestra en la figura siguiente.
59
Figura 20 Representacin grfica de una pila de monedas
Fuente: www.utpl.edu.ec/ecc/wiki/images/1/1e/Pilas.JPG Una pila, a un nivel fsico puede representarse tal como se muestra en figura 21, donde representa una pila de moneda o una pila de platos en un restaurante. Cuando se habla de una pila a nivel lgico, es una estructura de datos lineal compuesta de elementos del mismo tipo, en la cual cada uno de ellos solo puede ser insertado y eliminado por su parte final, es decir por el extremo final. La posicin final la llamamos cima o tambin cabeza de la pila; para darse una mejor representacin (abstraccin) de ella, su representacin grfica en el papel la se hace en forma vertical, con la cima en la parte de arriba. De esta forma cuando se aade un nuevo elemento solo podr ser colocado en la parte superior, piense en una pila de platos de cocina o en una pila de libros, los cuales se colocan en orden uno encima de otro. Por lo anterior las pilas tambin son llamadas listas en las cuales el ltimo elemento en entrar es el primero en salir, en ingls el acrnimo LIFO(Last Input, First Out). Leccin 2: Operaciones realizadas con pilas Las operaciones bsicas que se pueden realizar con la implementacin de una lista lineal condicionada tipo pila son: la insercin la eliminacin y la visualizacin de sus elementos. Esta implementacin se lleva a cabo haciendo uso de punteros con listas enlazadas al igual que por medio de arreglos unidimensionales.
60
Una Pila es una estructura de datos que almacena elementos de un tipo determinado, tal como se trat en la unidad uno en el tema relacionado con los tipos de datos. Es as como se sigue la poltica de que el primer elemento que se extrae, es decir se desapila, es el ltimo que se introdujo o se apil, cumpliendo con el enunciado que dice que el primero en salir, es el ultimo en entrar (LIFO). En la figura 22 se visualiza grficamente la entrada y salida de elementos de una pila. Figura 21 Entrada y salida de elementos de una pila
En principio, la pila est vaca y el puntero de la pila o CIMA debe estar en cero. Al insertar un elemento en la pila, se incrementa el puntero en una unidad. Mientras que al sacar un elemento de la pila se decrementa en una unidad el puntero, teniendo aplicabilidad las operaciones que se realizan con punteros tratadas en la Unidad uno. Siendo P el puntero (*P), al manipular una pila se deben realizar algunas comprobaciones. En una pila vaca no se pueden sacar datos, as que si (P = 0) no es posible eliminar elementos de la pila. En condiciones Ideales, una pila puede contener un nmero ilimitado de elementos y no producir nunca desbordamiento. En la prctica, el espacio de almacenamiento disponible es finito dependen de los recursos de memoria de la mquina (los recursos computacionales son finitos). La codificacin de una pila requiere un cierto equilibrio, ya que si la longitud mxima de la pila es demasiado grande, se gasta mucha memoria, mientras que un valor pequeo producir desbordamientos con mucha frecuencia. 61
Para trabajar fcilmente con pilas, es conveniente disear funciones o subprogramas para cada una de las operaciones que se realizan con pilas, es decir una funcin para insertar (push) otra para extraer (pop) o eliminar elementos y la funcin para visualizar los elementos insertados en la pila. No hay que olvidar comprobar con frecuencia si la pila est vaca; si el puntero es igual a NULL (puntero=NULL). En la siguiente seccin se enumeran los pasos algortmicamente para la implementacin de las operaciones que se realizan con las pilas. Para ello se declaran dos punteros: cima y auxiliar. Dado que los elementos se incorporan siempre por un extremo se tiene: 1. cima apunta al ltimo elemento de la pila es decir a NULL. 2. Reservar memoria (auxiliar) 3. Se Introduce la informacin en auxiliar elemento 4. Se hace que auxiliar cima es decir que apunte a donde cima 5. Se cambia cima para que apunte a donde lo hace auxiliar 6. La pila tiene un elemento ms. Esta rutina se repite para insertar los elementos requeridos en la pila. Los elementos se recuperan en orden inverso a como fueron introducidos. 1. Cima apunta al ltimo elemento de la pila. 2. Se hace que auxiliar apunte a donde apuntaba cima 3. Se hace que cima pase a apuntar a donde cima cima 4. Liberar memoria reservada (auxiliar) 5. La pila tiene un elemento menos El prototipo de nodo tpico para construir pilas es a travs de las estructuras. struct pila { int dato; struct pila *siguiente; };
Leccin 3: Operaciones bsicas con pilas paso a paso Despus de haber realizado la lectura detallada y analizado la aplicabilidad que se le puede dar a las pilas, se contina con la implementacin. Tal como se mencion en captulos anteriores. La implementacin de las estructuras lineales se puede realizar por medio de listas enlazadas con punteros o por medio de arreglos. En este curso profundizaremos con ms detalle en la implementacin de las listas enlazadas con punteros, la razn se debe a que el tema de los arreglos se trata en 62
detalle en los cursos Algoritmos e introduccin a la programacin, creando as la necesidad de profundizar en la implementacin de las estructuras lineales con el tema de punteros. Se recomienda seguir las siguientes instrucciones paso a paso y obtendr la implementacin bsica de una pila para el manejo de nmeros enteros ingresados en tiempo de ejecucin, es decir por teclado, para lo cual se har uso de un men de opciones y tres funciones bsicas para insertar visualizar y extraer datos de la pila. Se inicia abriendo un documento nuevo en cualquier editor del cual disponga, inclusive puede trabajar en el bloc de notas que provee su sistema operativo, para este caso usaremos el editor de Turbo C++, ingrese los archivos de cabecera, tambin llamados libreras, estas son bsicas por ser las ms usadas. #include<iostream.h> #include<stdio.h> #include<stdlib.h> #include<conio.h> #include<dos.h> En este caso se crea una estructura para el manejo de la informacin que contendr la pila, aunque solo se manejarn datos de tipo entero, es bueno recordar que una estructura es una coleccin de una o ms variables, agrupadas bajo un solo nombre para facilitar su manejo, a diferencia de las que se encuentran en arreglos, pueden ser de diferentes tipos de variables del C++, incluyendo arreglos y otras estructuras. Cada variable dentro de una estructura se llama un miembro de la estructura. Despus de cerrar la llave de la estructura y del punto y coma, en una lnea aparte se declaran las variables apuntadores requeridas para manipular los datos de la pila, estos son del mismo tipo de la estructura inicializados a NULL, son ellos *inicio y *c. struct pila { int numero; struct pila *sig; }; struct pila *inicio=NULL; struct pila *c=NULL; Otra forma de declarar la estructura es poner a continuacin de la definicin de la estructura una lista de uno o ms nombres de variables inicializadas llamadas instancias como se muestra acontinuacin. 63
struct pila { int numero; struct pila *sig; }*inicio=NULL, *c=NULL; Para continuar con el programa se escoge la segunda alternativa, que tiene entre sus miembros una variable llamada numero de tipo entero que guardar los nmeros que sern ingresados, al igual que un puntero llamado sig del tipo struct pila, del mismo tipo de la estructura usado para apuntar al siguiente nodo de la pila. Finalmente se declaran como instancias, dos variables apuntador del mismo tipo de la estructura llamadas inicio y c inicializadas a NULL como buena costumbre. Estas variables son llamadas instancias que son del mismo tipo de la estructura, inicio usada para reservar memoria y c usada para recorrer la pila; una vista de lo hecho hasta ahora es: Figura 22 Declaracin de la estructura pila
Implementacin del men de opciones para manipular la pila Se contina con la funcin principal haciendo uso de un men de opciones que a mi juicio es la mejor alternativa para interactuar con las estructuras lineales. En este punto es importante compilar el programa para depurar y corregir los posibles errores de sintaxis o de estructura, por lo pronto en las 3 opciones del men solo desplegar un corto mensaje ya que las funciones de insertar visualizar y extraer aun no han sido declaradas. Void main() 64
{ textcolor(10); int opc=0; do { clrscr(); cout<<" MANEJO DE UNA ESTRUCTURA TIPO PILA "; cout<<"\n\n\n"); cout<<"1. Insertar\n"); cout<<"2. Extraer\n"); cout<<"3. Visualizar\n"); cout<<"4. Salir\n\n"); cout<<"Digite la opcion: "); cin >>opc; switch (opc) { case 1: cout<<"inserter"; break; case 2: cout<<"extraer"; break; case 3: cout<<"visualizar"; break; case 4: exit(1); } getch(); }while (opc!=4) } El cdigo de la funcin main() o tambin llamada funcin principal que se incluye en el programa en construccin, no amerita algn tipo de explicacin, es conocido y muy usado en el curso Introduccin a la Programacin. Guarde el programa con un nombre, puede ser Pila.cpp. Compile y ejecute el programa, si lo digit cuidadosamente no generar errores de compilacin tan poco errores de ejecucin, se obtendr el siguiente resultado despus de haber digitado la opcin 1.
65
Figura 23 Men de opciones de la pila
El color verde del texto es gracias a la funcin textcolor(10) incluida en la primera lnea de cdigo de la funcin principal main(). Hasta aqu todo va bien, ahora se va a alimentar el programa con la funcin de insertar, la cual insertar los datos numricos en la pila. Implementacin de la funcin insertar() de la pila Se define la funcin insertar(), no tiene parmetros y no devolver ningn valor por eso es declarada de tipo void, esta lnea de cdigo se adiciona al cdigo justo despus de donde est definida la estructura, ser el sitio dentro del cdigo del programa para definir las tres funciones a utilizar tal como se muestra en la figura 25, una vez incluida la lnea de cdigo void insertar(void);
Figura 24 Definicin de la funcin insertar()
El otro cambio que se har al cdigo inicial, es en el case 1 del swich cambiamos el mensaje a desplegar cout<<insertar; por insertar(); usado por el programa principal para llamar a la funcin insertar(). Se visualiza en figura 26.
66
Figura 25 La funcin insertar() en el case 1
El siguiente cdigo contiene las instrucciones de la funcin insertar(), se incluir al final del cdigo, despus de cerrar las instrucciones de la funcin principal main(). void insertar (void) { inicio=(struct pila *)malloc(sizeof(struct pila)); clrscr(); cout<<"Digite el dato de tipo ENTERO: "); cin>>inicio->numero; if (c==NULL) { c=inicio; inicio->sig=NULL; } else { inicio->sig=c; c=inicio; } } En la figura 27 se visualiza el cdigo de las instrucciones de la funcin insertar().
67
Figura 26 Instrucciones de la funcin insertar()
Hasta el momento se tiene definida la funcin insertar() al inicio del cdigo, de igual manera se tiene todo el cdigo de la funcin insertar() y la instruccin para llamar a insertar() desde la funcin principal en la opcin 1 del case del men de opciones. Este procedimiento se debe repetir para las otras dos funciones que faltan, es decir la funcin visualizar() y la funcin extraer(). Para probar lo hecho hasta el momento se ejecuta el cdigo, pues ya se puede insertar los datos numricos a la pila, pero que bueno sera si se pudiesen listar los datos insertados. Para ello incluiremos en el cdigo en construccin la funcin visualizar() que es la opcin 3 de el men de opciones, se seguirn las indicaciones y los cambios al cdigo que se llevaron a cabo para la funcin insertar(). Implementacin de la funcin visualizar() de la pila Se inicia definiendo la funcin para viualizar los datos ingresados, la lnea de cdigo es: void visualizar(void); se incluye en el espacio usado para la definicin de las funciones justo en la lnea siguiente de donde se defini la funcin insertar. Posteriormente se modifica el case 3 del swich en el men de opciones, cambiando el mensaje a desplegar cout<<visualizar; por visualizar(); usado para que el programa principal haga el llamado a la funcin y as poder seleccionar esta opcin para tener en pantalla los datos previamente insertados a la pila. Siguiendo con la construccin de la pila queda adicionar al final del cdigo principal la declaracin completa de la funcin visualizar() que se incluye a continuacin y que no hay cdigo desconocido que amerite explicacin alguna. 68
void visualizar (void) { if (c==NULL) { clrscr(); cout<<"NO HAY ELEMENTOS A LISTAR"); } else { clrscr(); inicio=c; while (inicio!=NULL) { cout<<"Numero: "<<inicio->numero<<endl; inicio=inicio->sig; } } getch(); } Con la inclusin de este cdigo ya se tiene el programa con las opciones de insertar y visualizar los datos de la pila, es importante que compile el programa para depurar y corregir posibles errores. Sin embargo si sigui las instrucciones paso a paso no debe haber errores de sintaxis. Finalmente, solo queda incluir la opcin de extraer o eliminar datos de la pila con esta opcin tendremos la implementacin completa del programa bsico para el manejo de una pila. Manos a la obra. Implementacin de la funcin extraer de la pila Como en los dos casos anteriores se siguen las mismas directrices declarando la funcin extraer, en el espacio utilizado para tal fin, el cdigo es: Void extraer(void); con esta se completa la declaracin de las tres funciones como se puede observar en la figura 28.
69
Figura 27 Vista de la definicin de las funciones insertar, visualizar y extraer
Se contina modificando el case 2 del swich cambiando el mensaje a desplegar cout<<extraer; por extraer(); usado para que el programa principal haga el llamado a la funcin y as se podr seleccionar esta opcin para la eliminacin del ltimo elemento que fue insertado a la pila, se puede comprobar haciendo uso de la opcin 3 del men de opciones se visualizarn los datos que an quedan en la pila, pero no sin antes definir al final del cdigo principal de la pila, las instrucciones completas de la funcin extraer() que se incluyen a continuacin. void extraer (void) { if (c==NULL) { clrscr(); printf("NO HAY ELEMENTOS A ELIMINAR"); getch(); } else { inicio=c; cout<<"El dato a eliminar es: "<<inicio->numero; delay(1000); c=c->sig; free(inicio); } } Leccin 4: Anlisis del cdigo propuesto para implementar una pila Al hacer una revisin detallada al cdigo de la funcin insertar(), se encuentra la funcin malloc( ) tratada con detalle en la primera unidad, encargada de asignar un bloque de memoria del tamao requerido y regresa un apuntador. 70
El valor regresado por malloc( ) ha sido asignado a inicio, un apuntador al tipo struct pila, usando el apuntador y el operador de membresa indirecta ( -->) se puede accesar a los miembros de la estructura como lo indica la lnea de cdigo siguiente. cin>>inicio->numero; se encuentra un condicional que indica que si no hay elementos en el apuntador c est en NULL, entonces se insertan datos por primera vez a la pila. El apuntador c apunta a donde apunta inicio, lo indica la lnea de cdigo c=inicio; indirectamente guardan la misma informacin, posteriormente se hace que el nuevo nodo apunte a NULL en la lnea de cdigo inicio->sig=NULL; Si la pila no est vaca se hace que el nuevo nodo inicio a punte a c como lo indica el cdigo inicio->sig=c; ahora c es el nuvo nodo de la pila. Finaliza as las instrucciones de la funcin insertar( ). En cuanto a la funcin visualizar() no amerita un anlisis profundo, dado que son instrucciones bsicas como un condicional que verifica si el puntero c es igual a NULL, es decir si no hay elementos en la pila, saca un mensaje indicando que la pila est vaca, en caso contrario se hace un recorrido por cada elemento de la pila visualizando su contenido de la variable apuntador inicio. Revisando el cdigo de la funcin extraer( ), se tiene que en el caso de que existan datos en la pila se guardan en inicio la ubicacin de c segn el cdigo inicio=c; la instruccin cout<<"El dato a eliminar es: "<<inicio->numero; visualiza en pantalla el dato a eliminar, por medio de la funcin delay() se visualiza por un espacio de tiempo limitado el dato a eliminar. Finalmente es importante que analice el cdigo de cada funcin con el objetivo de que lo entienda, lo comprenda y pueda realizar las actividades propuestas, como aplicacin a situaciones reales. De igual manera puede plantear cambios para optimizar el cdigo propuesto, en caso de tener inquietudes recuerde que apelar a la bibliografa propuesta en el curso as como tambin puede consultar al tutor del curso. Es importante aclarar que en esta implementacin se plantea solo una de tantas alternativas posibles que se pueden usar para la implementacin de una estructura de datos lineales tipo pila. Para resumir la implementacin del manejo de la pila que se realiz paso a paso, se incluye el listado completo. Copie este cdigo, en su editor que puede ser el Bloc de Notas y lo guarda con el nombre Progra21.cpp en el directorio de ejecucin que por defecto est configurado el compilador C:\TC\BIN, con esto ya tiene listo el programa para que lo abra desde el compilador de Turbo C++ de cualquiera de sus versiones. 71
Cdigo completo de la implementacin de la pila Progra21.cpp #include <iostream.h> #include <stdio.h> #include <stdlib.h> #include <conio.h> #include <dos.h> struct pila { int numero; struct pila *sig; }*inicio=NULL, *c=NULL; void insertar(void); void extraer(void); void visualizar(void); void main() { textcolor(10); int opc=0; do { clrscr(); cout<<" MANEJO DE UNA ESTRUCTURA TIPO PILA "; cout<<"\n\n\n"; cout<<"1. Insertar\n"; cout<<"2. Extraer\n"; cout<<"3. Visualizar\n"; cout<<"4. Salir\n\n"; cout<<"Digite la opcion: "; cin >>opc; switch (opc) { case 1: insertar(); 72
break; case 2: extraer(); break; case 3: visualizar(); break; case 4: exit(1); } getch(); }while (opc!=4);
void insertar (void) { inicio=(struct pila *)malloc(sizeof(struct pila)); clrscr(); cout<<"Digite el dato de tipo ENTERO: "; cin>>inicio->numero; if (c==NULL) { c=inicio; inicio->sig=NULL; } else { inicio->sig=c; c=inicio; } } void visualizar (void) { if (c==NULL) { clrscr(); cout<<"NO HAY ELEMENTOS A LISTAR"; } 73
else { clrscr(); inicio=c; while (inicio!=NULL) { cout<<"Numero: "<<inicio->numero<<endl; inicio=inicio->sig; }
} getch();
void extraer (void) { if (c==NULL) { clrscr(); cout<<"NO HAY ELEMENTOS A ELIMINAR"; getch(); } else { inicio=c; cout<<"El dato a eliminar es: "<<inicio->numero; getch(); // delay(1000); c=c->sig; free(inicio); } } El resultado de la salida en pantalla de la implementacin de la pila se puede visualizar en la figura 29 que se presenta a continuacin.
74
Figura 28 Salida en pantalla de Progra21.cpp
Leccin 5: Aplicacin de las estructuras lineales tipo pilas Al inicio del captulo se mencion las dos posibilidades para la implementacin de las estructuras lineales por medio de listas enlazadas con punteros y por medio de arreglos unidimensionales, en el curso se har nfasis en la implementacin con listas enlazadas, es as como en el progra21.cpp se implementa una pila para gestionar datos de tipo entero, pero valdra la pena implementar una pila para la gestin de otro tipo de datos, para lo cual se pone a disposicin un cdigo completo para la implementacin de una pila para gestionar datos de cadena de carcter con nombres de personas. Progra22.cpp #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <iostream.h> void insertar(void); void extraer(void); void visualizar(void); struct pila { char nombre[20]; struct pila *ant; }; 75
struct pila *CAB=NULL,*AUX=NULL; main() { char opc; do { clrscr(); gotoxy(30,8); cout<<"1.- Insertar"; gotoxy(30,10); cout<<"2.- Extraer"; gotoxy(30,12); cout<<"3.- Visualizar la pila"; gotoxy(30,14); cout<<"4.- Salir"; gotoxy(20,16); cout<<"Ingrese una opcion : "; cin>> opc; // opc=getch( ); otra forma switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } // getch(); es opcional }while (opc!='4'); return 0; }
//FUNCION PARA INSERTAR DATOS A LA PILA 76
void insertar(void) { AUX=(struct pila *)malloc(sizeof(struct pila)); clrscr(); cout<<"INGRESAR DATOS DE LA PILA \n\n "; cout<<"Nombre: "; gets(AUX->nombre); if (CAB==NULL) { CAB=AUX; AUX->ant=NULL; } else { AUX->ant=CAB; CAB=AUX; } } //FUNCION DE ELINIMAR ELEMENTOS DE LA PILA void extraer(void) { if (CAB==NULL) return; AUX=CAB; CAB=CAB->ant; free(AUX); cout<<"\n Se elimino a " <<AUX->nombre <<" de la pila"; getch(); } //FUNCION DE VISUALIZAR LA PILA void visualizar(void) { if (CAB==NULL) return; clrscr(); 77
AUX=CAB; cout<<"DATOS DE LA PILA \n\n "; while (AUX!=NULL) { cout<<"Nombre: "<<AUX->nombre <<endl; AUX=AUX->ant; } getch( );
El resultado despus de haber compilado y ejecutado el listado llamado progra22 se conjuga en la figura22 que se muestra a continuacin. Figura 29 Salida en pantalla de Progra22.cpp
Progra23.cpp #include <stdio.h> #include <conio.h> #include <stdlib.h> /*************** DEFINICION DEL NODO (Estructura) **************/ struct nodo { char nombre[40]; // Datos del nodo Entero int edad; double salario; struct nodo *sig; // Puntero a otro nodo }; /****************************************************************/ struct nodo *tope; // tope de nuestra PILA 78
/************************ Push (Insertar) ***********************/ void Push() // Funcion que inserta datos a la pila { struct nodo *p; p = (struct nodo*) malloc(sizeof(struct nodo)); // reservamos // espacio para el nodo (dato, sig) printf("Escriba el nombre: "); scanf("%s",p->nombre); if(tope == NULL) { // si no hay elemetos el tope esta en NULL // insertamos por primera vez a la pila printf("Escriba la Edad: "); scanf("%d",&p->edad); printf("Escriba el Salario: "); scanf("%d",&p->salario); p->sig = NULL; // hacemos que el nuevo nodo apunte a NULL tope = p; // Ahora el tope es el nuevo nodo return; } // si no printf("Escriba la Edad: "); scanf("%d",&p->edad); printf("Escriba el Salario: "); scanf("%d",&p->salario); p->sig = tope; // hacemos que el nuevo nodo apunte al tope tope = p; // ahora el tope es el nuevo nodo } /************************** Pop (Sacar) *************************/ void Pop() { if(tope == NULL) { printf("PILA VACIA\n"); return; } int i; // es para almacenar el dato que tiene el tope struct nodo *tmp; // temporal para almacenar la direccion del tope tmp = tope; // guardamos en tmp la ubicacion del tope tope = tmp->sig; // hacemos que el tope sea el anterior nodo ingresado // sacamos el dato del nodo que estaba como tope 79
printf("Nombre : %s\n", tmp->nombre); printf("Edad : %d\n", tmp->edad); printf("Salario : %d\n", tmp->salario); free(tmp); // liberamos la memoria reservada para el tope
int menu() { int o = 0; do{ clrscr(); // limpiar pantalla printf(" GESTION DE UNA PILA DE EMPLEADOS: NOMBRE, EDAD, SALARIO\n\n"); printf("1. Insertar Empleado\n"); printf("2. Sacar Empleado\n"); printf("3. Vaciar Pila de Empleados\n"); printf("4. Salir\n\n"); printf("Ingrese la opcion : "); scanf("%d",&o); // leer opcion del teclado }while( o < 1 || o > 4); // mientras sea menor que 1 o mayor que 4 clrscr(); return o;
int main() { tope = NULL; // hacemos que el tope no apunte a nada (pila vacia) int d = 0; do { d = menu(); // retorna opcion switch(d) { case 1: Push(); break; case 2: { Pop(); getch(); break; } case 3:
80
} }while(d != 4); // mientras que la opcion no sea 4 return 0;
{ while(tope != NULL) Pop(); printf("PILA VACIA"); getch(); break; }
La salida en pantalla de progra23.cpp que se implementa con la sintaxis del lenguaje C, se puede visualizar en la figura 31 como se muestra a continuacin. Figura 30 Salida en pantalla de Progra23.cpp
81
CAPITULO 5: COLAS Introduccin Las colas al igual que las pilas, son una estructura de datos de tipo lineal condicionadas donde las inserciones y eleminaciones se realizan por extremos diferentes. Se abordan los temas relacionados con los conceptos bsicos de las colas, las operaciones que se pueden realizar con las colas, todo conjugado en programas de aplicacin, implementados con apuntadores. Se hace uso de un men de opciones para cada programa y funciones para la insercin, visualizacin, y eliminacin de nodos de la cola. Al igual que en los anteriores captulos, cada uno de los programas aqu presentados, estn previamente compilados y depurados de tal manera que se mustra la salida en pantalla de cada uno. Lo anterior garantiza al estudiante que puede guiarse en el cdigo fuente para hacerle modificaciones y proponer soluciones a entornos reales. Leccin 6: Conceptos bsicos de colas Las colas son otro tipo de estructura de datos lineales, similar a las pilas, diferencindose de ellas en el modo de insertar/eliminar elementos. As pues, la diferencia con las pilas reside en el modo de entrada/salida de datos; en las colas las inserciones se realizan al final de la lista, no al principio. Por ello, las colas se usan para almacenar datos que necesitan ser procesados segn el orden de llegada. Una aplicabilidad de las colas puede realizarse en un sistema de computacional manejado a travs de una red de computadoras donde se comparte una sola impresora para todos los equipos conectados a la red; de tal manera que se imprimirn los documentos en el orden en que se hace la peticin de impresin de cada usuario. Formando as una cola de impresin. Definicin de una cola Una cola es una estructura lineal de datos condicionada, en la que las eliminaciones se realizan al principio de la lista, es decir, al frente, y las inserciones se realizan en el extremo opuesto de la lista, es decir, al final. En las colas el elemento que entr de primero sale tambin de primero; por ello se conocen como listas FIFO, en ingles (first-in, first-out), primero en entrar, primero en salir. 82
Una muy buena representacin grfica de las estructuras de datos tipo cola puede visualizarse en la Figura 32, que se muestra a continuacin.
Figura 31 Representacin grfica de una cola de personas.
Fuente: http://www.utpl.edu.ec/ecc/wiki/index.php/Imagen:Cola.JPG Aplicacin de las estructuras Lineales tipo Colas En la vida real se tiene ejemplos numerosos de colas: la cola de un autobuses, cola para ingresar al cine, caravana de coches en una calle, etc. En todas ellas el primer elemento (pasajero, coche, etc) que llega es el primero que sale. En informtica existen numerosas aplicaciones de las colas. Por ejemplo, en un sistema de tiempo compartido suele haber un procesador central y una serie de perifricos compartidos: discos, impresoras, etc. Los recursos se comparten por los diferentes usuarios y se utiliza una cola para almacenar los programas o peticiones de los diferentes usuarios que esperan su turno de ejecucin. Es as como en un sistema multiprocesos, el procesador central atiende normalmente en un riguroso orden de llamada de peticiones del usuario; por tanto todas las llamadas se almacenan en una cola. Existe otra aplicacin muy utilizada que se denomina cola de prioridades; en ella el procesador central no atiende por riguroso orden de llamada, aqu el procesador atiende por prioridades asignadas por el sistema o bien por el usuario y slo dentro de las peticiones de igual prioridad se producir una cola4.
Tomado de: http://www.uhu.es/17207-18209/Transparencias/Tema3.pdf
83
Una muy buena implementacin de las colas podra realizarse un programa para manejar un planificador de citas en un consultorio mdico, de tal manera que cada solicitud de una cita se va almacenando en la cola el nombre del paciente y la hora de la cita, en el mismo orden de fecha y hora en que se solicit ser atendida. En general en una cola, de la vida diaria, el primero que llega ser atendido primero, pasando a continuacin el segundo de la cola al frente; y cada que llega un nuevo elemento este se colocar al final de la cola. De aqu que el extremo por donde se insertan los elementos se llamar "final" y por donde se retiran "frente". Debido a esto ltimo las colas tambin son llamadas listas en las cuales el primer elemento en entrar es el primero en salir. Para las colas que se trabajarn se sobreentender, a menos de decir lo contrario, que la regla es que siempre el primero se atiende primero.
Figura 32 Representacin grfica de una cola
Leccin 7: Operaciones bsicas con colas Nuevamente se encuentra una situacin particular ante una estructura de datos con muy pocas operaciones disponibles. Las colas slo permiten aadir, visualizar y eliminar elementos. Aadir: Inserta un elemento al final de la cola. Extraer: elimina un elemento del principio de la cola. Visualizar: muestra los elementos insertados en la cola Las operaciones en detalle que se pueden realizar con una cola son: Acceder al primer elemento de la cola. Aadir un elemento al final de la cola. Eliminar el primer elemento de la cola. Vaciar la cola. Verificar el estado de la cola: vaca, llena. 84
Implementacin de las listas tipo cola Para la implementacin de estructura de datos tipo cola utilizaremos las listas enlazadas con apuntadores al igual que el uso de arreglos unidimensionales. Las funciones que manejarn la cola sern: Insertar() y Atender(). Se Desarrollarn estas dos funciones de forma "simultnea"; Implementacin de las colas por con arreglos En vista de que las estructuras de datos lineales pueden ser implementadas tambin por medio de arreglos unidimensionales se ha puesto a consideracin para efectos de anlisis el siguiente listado llamado Progra24.cpp. Progra24.cpp #include <iostream.h> #include <iomanip.h> #include <conio.h> const int MaxiCola = 5; const int nulo = 1; int frente = nulo; int final = nulo; int cola[MaxiCola]; void Insertar(){ if ( (final+1 == MaxiCola && frente == 0) || (final+1 == frente) ) { cout << "La cola est llena "; getch(); } else if (frente == nulo) { //la cola estaba vaca frente = final = 0; cout << "\n\n Ingrese el elemento a insertar: "; cin >> cola[frente]; } else { final++; if (final == MaxiCola) final = 0; 85
cout << "\n\n Ingrese el Elemento a insertar: "; cin >> cola[final];
void Atender() { if (frente == nulo) cout << "\nCola vacia\a"; else { cout << "\nEliminando elemento: " << cola[frente]; if (frente == final) // cola qued vaca frente = final = nulo; else{ frente++; if (frente == MaxiCola) frente = 0; } } } void Listar() { int i; if (frente==nulo) cout << "\nLa cola esta vacia \a\n"; else if (frente <= final) for (i=frente; i <= final; i++) cout <<setw(4) << cola[i]; else { for (i=frente; i < MaxiCola; i++) cout << setw(4) << cola[i]; for (i=0; i <= final; i++) cout << setw(4) << cola[i];
void main() { char opcion; do{ 86
} El resultado de la salida en pantalla del Listado Implementado con arreglos llamado progra24.cpp se puede visualizar en la siguiente figura 34. Figura 33 Salida en pantalla de progra24
clrscr(); Listar(); cout << "\nIMPLENTACION DE UNA COLA CON ARREGLOS \n"; cout << "\n\nInsertar Atender Salir \n"; switch (opcion=getch()){ case 'I':; case 'i': Insertar(); break; case 'A':; case 'a': Atender(); break; } } while (opcion != 'S' && opcion != 's');
Leccin 8: Implementacin de las Colas por medio de Punteros Representacin de las Colas Las colas tambin se pueden representar como estructuras dinmicas, para ello se necesitan dos punteros que se llamarn: CAB, FIN y AUX. Las operaciones con colas son muy sencillas, prcticamente no hay casos especiales, salvo que la cola est vaca. Aadir un elemento a una cola vaca Se parte del hecho de que ya se tiene el nodo a insertar y por supuesto un puntero que apunte a l, adems los punteros que definen la cola, CABEZA, FINAL y AUXILIAR que se inicializan a cero es decir valdrn NULL. El proceso es muy simple, bastar con que: 87
1. AUXILIAR->sig apunte a NULL. 2. Que los punteros CABEZA y FINAL apunten a AUXILIAR. Aadir elemento en una cola no vaca De igual manera que el caso anterior se parte de un nodo a insertar, con un puntero que apunte a l, y de una cola, en este caso, al no estar vaca, los punteros CABEZA y FINAL no sern nulos. El proceso sigue siendo muy sencillo: 1. Se Hace que AUXILIAR->siguiente apunte a NULL. 2. Despus que FINAL->siguiente apunte a AUXILIAR. 3. Se actualiza FINAL, haciendo que apunte a AUXILIAR. La siguiente funcin resume el anterior anlisis realizado para la insercin de nodos a la cola void insertar(void) { AUXILIAR=(struct cola *)malloc(sizeof(struct cola)); clrscr(); cout<<"Nombre: "; gets(AUXILIAR->nombre); AUXILIAR->sig=NULL; if (FINAL==NULL) FINAL=CABEZA=AUXILIAR; else { FINAL->sig=AUXILIAR; FINAL=AUXILIAR; } } Extraer un elemento de una cola Extraer un elemento de una cola, implica eliminarlo definitivamente de la lista Se usar un puntero a un nodo auxiliar llamado CABEZA que apunta a la cabeza de la cola. Si la cola est vaca si CABEZA==NULL retorna al programa principal, desplegando el mensaje que indica el estado de la cola. . 1. Se hace que AUXILIAR apunte al primer elemento de la cola, es decir a CABEZA. 2. Se asigna a CABEZA la direccin del segundo nodo de la pila: CABEZA=CABEZA->sig. 88
3. Se guarda el contenido del nodo para devolverlo como retorno, hay que recordar que la operacin de lectura en colas implican tambin borrar. 4. se libera la memoria asignada al primer nodo, el que se quiere eliminar. Free (AUXILIAR); La siguiente funcin resume el anterior anlisis realizado para la eliminacin de nodos a la cola void extraer(void) { if (CABEZA==NULL) { cout<<"No hay elementos en la cola"; getch(); } else { AUXILIAR=CABEZA; cout<<"El dato eliminado es: "<<AUXILIAR->nombre; getch(); CABEZA=CABEZA->sig; free(AUXILIAR); } } Visualizar los elementos de una cola Se har uso del puntero llamado CABEZA que apunta a la cabeza de la cola. Si la cola est vaca si CABEZA==NULL retorna al programa principal desplegando el mensaje que indica el estado de la cola. En caso contrario, que la cola tenga elementos 1. Se hace que AUXILIAR apunte al primer elemento de la cola, es decir a la CABEZA. 2. inicia el recorrido por todos los elementos de la cola, por medio del apuntador AUXILIAR, AUXILIAR->nombre, posteriormente a AUXILIAR se le asigna el valor del siguiente nodo, AUXILIAR=AUXILIAR->sig el proceso se repite hasta que este sea igual a NULL. La siguiente funcin representa el cdigo que permite la visualizacin de los datos de la cola. void visualizar(void) { if (CABEZA==NULL)
89
} else { clrscr(); AUXILIAR=CABEZA; while (AUXILIAR!=NULL) { cout<<"Nombre:" <<AUXILIAR->nombre <<"\n"; AUXILIAR=AUXILIAR->sig; } getch(); } Leccin 9: Implementacin del cdigo completo de la cola El siguiente listado llamado Progra25.cpp muestra el cdigo completo de la implementacin de la cola objeto del anlisis en la leccin anterior. Progra25.cpp #include <stdio.h> #include <iostream.h> #include <conio.h> #include <stdlib.h> void insertar(void); void extraer(void); void visualizar(void); struct cola { char nombre[20]; struct cola *sig; }*CABEZA=NULL,*AUXILIAR=NULL,*FINAL=NULL; main() {
cout<<"NO HAY ELEMENTOS EN LA COLA"; getch();
char opc; do { 90
clrscr(); gotoxy(30,8); cout<<"1.- Insertar"; gotoxy(30,10); cout<<"2.- Extraer"; gotoxy(30,12); cout<<"3.- Visualizar la cola"; gotoxy(30,14); cout<<"4.- Salir"; gotoxy(25,16); cout<<"Ingrese la opcion :"; opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); return 0;
void insertar(void) { AUXILIAR=(struct cola *)malloc(sizeof(struct cola)); clrscr(); cout<<"Nombre: "; gets(AUXILIAR->nombre); AUXILIAR->sig=NULL; if (FINAL==NULL) FINAL=CABEZA=AUXILIAR; else { FINAL->sig=AUXILIAR; FINAL=AUXILIAR; } }
91
void extraer(void) { if (CABEZA==NULL) { cout<<"No hay elementos en la cola"; getch(); } else { AUXILIAR=CABEZA; cout<<"El dato eliminado es: "<<AUXILIAR->nombre; getch(); CABEZA=CABEZA->sig; free(AUXILIAR); } } void visualizar(void) { if (CABEZA==NULL) { cout<<"NO HAY ELEMENTOS EN LA COLA"; getch(); } else { clrscr(); cout<<"ELEMENTOS DE LA COLA \n\n"; AUXILIAR=CABEZA; while (AUXILIAR!=NULL) { cout<<"Nombre:" <<AUXILIAR->nombre <<"\n"; AUXILIAR=AUXILIAR->sig; } getch(); } } La salida en pantalla de Progra25.cpp se puede visualizar en la figura 35 que se muestra a continuacin.
92
Leccin 10: Aplicacin de una cola en un entorno real planificador de citas Un Ejemplo real como aplicacin de las colas es la de un consultorio mdico donde el Doctor tiene una secretaria a su servicio para manejar su agenda de citas mdicas, el telfono y la correspondencia. La secretaria organiza la agenda de las citas mdicas asignadas a los pacientes que atender el Doctor. Las llamadas solicitando una cita mdica se atienden en el orden de llegada. El siguiente programa de aplicacin de una cola implementa un planificador de citas con un men de iteraciones para gestionar la cola. Progra26.cpp #include <string.h> #include <stdlib.h> #include <stdio.h> #include <ctype.h> #include <conio.h> #include <iostream.h> #define MAX 5 char *p[MAX], *crecup(void); int spos=0; int rpos=0; char *crecup(void); void intro(void), calmac(char *c), revisar(void), eliminar(void); int main() { clrscr(); char s[80]; 93
register int t; for(t=0;t<MAX; ++t) p[t] = NULL; //Inicializa el arreglo for(;;) { cout<<"\n\nOPCIONES DE ITERACION DE LA COLA\n\n"; cout<<"I. Introducir\n"; cout<<"R. Revisar\n"; cout<<"E. Eliminar\n"; cout<<"S. Salir\n\n"; cout<<"Seleccione la opcin : "; gets(s); *s = toupper(*s); switch(*s) { case 'I': intro(); break; case 'R': revisar(); break; case 'E': eliminar(); break; case 'S': exit(0); }
} }
//INTRODUCIR CITAS EN LA COLA void intro(void) { char s[256], *p; do { cout<<"Introduce la cita " <<spos+1 <<" : "; gets(s); if(*s==0) break; //no hay entradas p = (char *)malloc(strlen(s)+1);
94
if(!p) { cout<<"No hay memoria \n"; return; } strcpy(p, s); if(*s)calmac(p); }while(*s); clrscr();
//ver que hay en la cola void revisar(void) { clrscr(); register int t; cout<<endl <<endl <<" LISTADO DE CITAS" <<endl <<endl; for(t=rpos;t<spos;++t) cout<<t+1 <<p[t] <<endl; } //Eliminar una cita de la cola void eliminar(void) { clrscr(); char *p; if ((p=crecup())==NULL) return; cout<<endl <<"CITA ELIMINADA:" <<p; } //guardar una cita void calmac(char *c) { if(spos==MAX) { cout<<"\n La Cola esta llena. Presione Intro \n"; return; } p[spos] = c; spos++;
95
} //Recuperar una cita char *crecup(void) { if(rpos==spos) { cout<<"No hay mas citas \n"; return NULL; } rpos++; return p[rpos-1]; } El resultado despus de haber compilado, depurado y ejecutado el listado Progra26.cpp se puede visualizar en la figura 36, que se muestra a continuacin. Figura 35 Salida en pantalla de progra26.cpp
El Listado llamado Progra26.cpp, implementa un planificador de citas, sera importante que analice detenidamente cada una de las instrucciones del cdigo y as establecer las diferencias del cdigo con la implementacin de una PILA, as mismo se pide que modifique el programa para que guarde adems del nombre de la persona, la hora de la cita, de tal manera que al visualizar la cola se muestren los datos completos.
96
CAPITULO 6: LISTAS Introduccin Las listas al igual que las pilas y las colas, son una estructura de datos de tipo lineal diferencindose de las anteriores en el hecho de que pueden las inserciones y eleminaciones se en cualquier parte de la lista. Esto hace que tengan mayor aplicabilidad en el entorno real. Se abordan los temas relacionados con los conceptos bsicos de las listas, as como tipos de listas y las operaciones que se pueden realizar con las listas, todo conjugado en programas de aplicacin, implementados con apuntadores. Se hace uso de un men de opciones para cada programa y funciones para la insercin, visualizacin, eliminacin y bsqueda de nodos en la lista. Al igual que en los anteriores captulos, cada uno de los programas aqu presentados, estn previamente compilados y depurados de tal manera que se mustra la salida en pantalla de cada uno. Lo anterior garantiza al estudiante que puede guiarse en el cdigo fuente para hacerle modificaciones y proponer soluciones a entornos reales. Leccin 11: Concepto bsicos de Listas Una lista enlazada es una coleccin o secuencia de elementos del mismo tipo dispuestos uno detrs de otro, en el que cada elemento se liga al siguiente elemento por un enlace que no es ms que un puntero previamente definido. Las listas segn su estructura se han dividido en cuatro grandes categoras: 1.- Listas Simplemente enlazadas 2.- Listas Doblemente enlazadas 3.- Listas Circular simplemente enlazada 4.- Lista circular doblemente enlazada Lista simplemente enlazada Entre las listas simplemente enlazadas se encuentra un tipo de lista llamada Lista contigua: La cual se compone de un conjunto de elementos de un tipo dado que 97
se encuentran ordenados y pueden variar en nmero. general, que incluye los ficheros y vectores.
Esta es una definicin
Las entradas de una gua o directorio telefnico, por ejemplo, estn en lneas sucesivas, excepto en las partes superior e inferior de cada columna. Una lista lineal se almacena en la memoria principal de una computadora en posiciones sucesivas de memoria; cuando se almacenan en cinta magntica, los elementos sucesivos se presentan en sucesin en la cinta. Esta asignacin de memoria se denomina almacenamiento secuencial. Posteriormente, se ver que existe otro tipo de almacenamiento denominado encadenado o enlazado. Una lista lineal se almacena en la memoria de la computadora en posiciones sucesivas o adyacentes y se procesa como un arreglo unidimensional. En este caso, el acceso a cualquier elemento de la lista es fcil; sin embargo, la insercin o borrado requiere un desplazamiento de lugar de los elementos que le siguen y en consecuencia el diseo de un algoritmo especfico. Para permitir operaciones con las listas como arreglos se deben dimensionar stos con tamao suficiente para que contengan todos los posibles elementos de la lista. La insercin o eliminacin de un elemento, excepto en la cabecera o final de la lista, necesita una traslacin de un parte de los elementos de la misma: la que precede o sigue a la posicin del elemento modificado. Las operaciones directas de aadir y eliminar se efectan nicamente en los extremos de la lista. Esta limitacin es una de las razones por las que esta estructura es poco utilizada. Operaciones con listas lineales contiguas Las operaciones que se pueden realizar con listas lineales contiguas son: Insertar, eliminar o localizar un elemento. Determinar el tamao nmero de elementos de la lista. Recorrer la lista para localizar un determinado elemento. Clasificar los elementos de la lista en orden ascendente o descendente. Unir dos o ms listas en una sola. Dividir una lista en varias sublistas. Copiar la lista. Borrar la lista. 98
Representacin grfica de una lista contigua Figura 36 Representacin grfica de una lista contigua
Como se puede apreciar en la figura 36 se trata de una lista contigua de elementos de tipo entero representados en un arreglo unidimensional de 6 campos, de tal manera que no es posible insertar un nuevo elemento por que la lista est completa. Esta es una de las desventajas de este tipo de lista.
Leccin 12: Listas enlazadas Las listas enlazadas o de almacenamiento enlazado son mucho ms flexibles y potentes, su uso es mucho ms amplio comparado con la lista contigua. Una lista enlazada o encadenada es un conjunto de elementos del mismo tipo en los que cada elemento contiene la posicin o direccin del siguiente elemento de la lista. Cada elemento de la lista enlazada debe tener al menos dos campos: un campo que tiene el valor del elemento y un campo (enlace, link) que contiene la posicin del siguiente elemento, es decir, su conexin, enlace o encadenamiento. Los elementos de una lista son enlazados por medio de los campos enlaces. Una lista enlazada sin ningn elemento se llama lista vaca. Su puntero inicial o de cabecera tiene el valor nulo, es decir apunta a NULL. *puntero NULL; Una lista enlazada se define por: El tipo de sus elementos: el campo de informacin donde se almacenan los datos y el campo de enlace apunta al siguiente elemento lo define un puntero. Un puntero de cabecera que permite acceder al primer elemento de la lista. Un medio para detectar el ltimo elemento de la lista: puntero nulo (NULL).
99
Figura 37 Representacin grfica de listas enlazadas
En la figura 37. Se puede observar las diferentes representaciones graficas del ltimo nodo de una lista enlazada. Operaciones con las listas enlazadas Generalmente las operaciones bsicas que se pueden realizar en una lista enlazada son las siguientes: Operacin de Recorrido. Esta operacin consiste en visitar cada uno de los elementos que forman la lista. Para ello se comienza con el primer elemento, se toma el valor del campo enlace para avanzar al segundo elemento, el campo enlace de este elemento dar la direccin del tercer elemento y as sucesivamente hasta que la informacin del campo enlace sea NULL, lo que indica que el recorrido lleg a su final. Operacin de Insercin. Esta operacin consiste en agregar un nuevo elemento a la lista. Se pueden considerar tres casos especiales: Insertar un elemento al inicio de la lista. Insertar un elemento antes o despus de un determinado elemento o nodo de la lista. Insertar un elemento al final de la lista.
Operacin de Bsqueda. Esta operacin consiste en visitar cada uno de los elementos, tomando al campo enlace como puntero al siguiente elemento a visitar en la lista. Operacin de Borrado. La operacin de borrado consiste en eliminar un elemento de la lista, considerando que se debe redefinir los enlaces involucrados en la operacin. Se pueden presentar cuatro casos bsicos: 100
Eliminar el primer elemento de la lista. Eliminar el ltimo elemento de la lista. Eliminar de la lista un elemento especfico, es decir, que tenga cierta informacin. Eliminar de la lista el elemento anterior o posterior al elemento que tiene cierta informacin.
Implementacin de una lista enlazada con punteros El siguiente programa se plantea como ejemplo gua para implementar una lista simplemente enlazada con punteros, para gestionar nmeros enteros, ingresados por teclado con funciones de crear, insertar, eliminar, recorrer y buscar. Las eliminaciones y la bsqueda, se realizan en cualquier lugar de la lista. Progra27.cpp #include <iostream.h> #include <stdlib.h> #include <stdio.h> #include <conio.h> struct lista { int dato; struct lista *sig; }; void crear(struct lista **); void insertar(struct lista **, int); void eliminar(struct lista **, int); void recorrer(struct lista **); int buscar(struct lista **, int); int main() {
clrscr(); struct lista *entero; int dato; crear(&entero); 101
} // funciones de listas simplemente enlazadas void crear(struct lista **entero) { *entero = NULL; } void insertar(struct lista **entero, int dato) { struct lista *auxiliar, *puntero, *anterior; auxiliar = new lista; if(!auxiliar) { cout<<"error:memoria insuficiente"<<endl; exit(1); }
cout<<"OPERACIONES CON LA LISTA ENLAZADA\n\n "; cout<<"Para finalizar la insercion Ingrese el cero\n\n "; cout<<"Ingrese un numero: "; cin>>dato; while(dato != 0) { insertar(&entero, dato); cout<<"Ingrese un numero: "; cin>>dato; } cout<<"\n \n ELEMENTOS DE LA LISTA \n\n"; recorrer(&entero); cout<<"\n \n Ingrese el numero a eliminar: "; cin>>dato; eliminar(&entero, dato); recorrer(&entero); cout<<"\n \n Ingrese el numero a buscar: "; cin>>dato; if(buscar(&entero,dato) == 1) cout<<"\n El numero "<<dato<<" fue encontrado\n"; else cout<<"Enl numero no existe "<<endl; getchar(); return 0;
102
auxiliar->dato = dato; anterior = NULL; puntero = *entero; //puntero es el puntero auxiliar que recorre la lista while((puntero != NULL) && (puntero->dato < dato)) { anterior = puntero; puntero = puntero->sig; } if(anterior == NULL) { auxiliar->sig = *entero; *entero = auxiliar; } else { anterior->sig = auxiliar; auxiliar->sig = puntero; } } void eliminar(struct lista **entero, int dato) { struct lista *puntero, *anterior; puntero = *entero; anterior = NULL; while((puntero != NULL) && (puntero->dato < dato)) {
} if(puntero->dato != dato)
anterior = puntero; puntero = puntero->sig;
cout<<"El numero no existe "<<endl; else { if(anterior == NULL) //1er lista *entero = (*entero)->sig; else 103
anterior->sig = puntero->sig; delete puntero; } }
void recorrer(struct lista **entero) { struct lista *puntero; puntero = *entero; while(puntero != NULL) { cout<<puntero->dato<< " "; puntero = puntero->sig; } } int buscar(struct lista **entero, int dato) { struct lista *puntero; puntero = *entero; while((puntero != NULL) && (puntero->dato < dato)) puntero = puntero->sig; if(puntero->dato == dato) return 1; else return 0;
El resultado de la salida en pantalla del listado anterior se puede observar en la siguiente figura 38. Analice el cdigo y plantee modificaciones al programa, en busca de mejoras.
104
Leccin 13: Ms a cerca de listas enlazadas En la implementacin de las listas enlazadas se pueden encontrar muchas formas de representacin, dependiendo de los recursos que se tengan relacionados con el dominio del lenguaje C++. Una forma ms sencilla de representar una lista enlazada de nmeros enteros se presenta en el listado llamado progra28.cpp en donde los datos ya estn predefinidos. Progra28.cpp #include <conio.h> #include <iostream.h> #include <stdlib.h> struct lista { int nuevo; struct lista *sig; }; int main() { clrscr(); struct lista *L; 105
struct lista *P; int i; L=NULL; cout<<"RESULTADO DE LA LISTA\n\n"; for(i=1;i<=6;i++) { cout <<i <<"-"; P=(struct lista *)malloc(sizeof(struct lista)); //Reserva memoria para el nodo P-> nuevo=3; //Introduce la informacin P->sig=L; //Reorganiza L=P; //los enlaces } cout <<P->nuevo <<"\n\n"; cout << "Donde " <<P->nuevo <<" es el Nuevo nodo insertado al final "; free (P); getch(); return 0; } El resultado de la salida en pantalla de progra28.cpp se visualiza en la figura 40, que se muestra continuacin. Figura 39 Salida en pantalla de progra28.cpp
Anlisis de Progra28.cpp Al analizar un poco el cdigo de progra28.cpp se tiene definida una estructura llamada lista, que tiene como miembros a un puntero llamado *nuevo y a *sig que es el enlace al siguiente elemento de la lista y es del tipo de la estructura, al igual que los punteros *L y *P, utilizados para gestionar la lista. Se define la variable i que es de tipo entero utilizada para el recorrido del ciclo for. El cual est predefinido para que repita el proceso de insertar elementos 5 veces al estar definido as: for(i=1;i<=6;i++).
106
El puntero P es utilizado para la reserva de memoria que se hace por medio de Malloc(), lo que indica que P guardar los elementos que se inserten a la lista, pero se requiere otro puntero que recorra la lista y esa labor la hace L. Siguiendo algortmicamente las instrucciones del programa se tiene que se almacena un nuevo dato que es el nmero 3 y que este se guarda en el apuntador P tal como lo indica la instruccin p->nuevo=3. Con la instruccin P->sig=L; se hace que p apunte al siguiente elemento de lista posteriormente se reorganizan los enlaces en la instruccin L=P. Finalmente se imprime los datos de ciclo for almacenados en la variable, es decir los nmeros del 1 al 5, seguido del valor almacenado en P para el cual se reserv memoria que se libera antes de finalizar el programa. Continuando con la implementacin de las listas enlazadas, vale la pena analizar el siguiente cdigo de progra29.cpp, implementado con punteros que crea una lista enlazada de 6 nmeros enteros ingresados por teclado en tiempo de ejecucin, imprime todos sus elementos y adicionalmente arroja la sumatoria de los elementos de la lista.
Progra29.cpp #include <stdlib.h> #include <iostream.h> #include <conio.h> struct nodo { int dato; struct nodo *sig; }*l=NULL,*primero=NULL; int main() { clrscr(); int acumulador=0; int i=0, vector[6]; cout<<"IMPLEMENTACION DE UNA LISTA ENLAZADA\n\n"; cout<<"Ingrese 6 numeros\n"; for(i;i<6;i++) { cin>> vector[i]; acumulador = acumulador + vector[i]; 107
} for(i;i<6;i++) { primero=(struct nodo *)malloc(sizeof(struct nodo)); primero->dato=vector[i-1]; primero->sig = l; l = primero; } cout<<"\nLista creada. Preseione una tecla "; getch(); cout<<"\nLa sumatoria de la lista es : " <<acumulador; cout<<" \n"; while(l!=NULL) { cout<< l->dato; l=l->sig; } free(primero); getch(); return 0;
El resultado despus de haber compilado y depurado el cdigo es el que se visualiza en la figura 40,
108
Leccin 14: Listas doblemente enlazadas Las listas doblemente enlazadas son un tipo de lista lineal en la que cada nodo tiene dos enlaces, uno que apunta al nodo siguiente, y el otro que apunta al nodo anterior. Las listas doblemente enlazadas no necesitan un nodo especifico para acceder a ellas, ya que presentan una gran ventaja comparada con las listas enlazadas y es que pueden recorrerse en ambos sentidos a partir de cualquier nodo de la lista, ya que siempre es posible desde cualquier nodo alcanzar cualquier otro nodo de la lista, hasta que se llega a uno de los extremos. La creacin de las listas doblemente enlazadas se hace de igual manera que con las listas enlazadas, es decir a travs de una estructura, la diferencia radica en que para esta tipo de lista doble se requiere otro enlace que apunte al nodo anterior. He aqu la definicin de la estructura llamada ListaDoble. struct ListaDoble { int dato; struct nodo *siguiente; struct nodo *anterior; };
Representacin grfica de una lista doblemente enlazada Una forma grfica de representar una lista doblemente enlazada se puede visualizar en la figura 41, que se muestra a continuacin.
Figura 41 Representacin grfica de una lista doblemente enlazada
El movimiento a travs de listas doblemente enlazadas es ms flexible, ya que como se ver en esta leccin las operaciones de bsqueda, insercin y
109
borrado, tambin tienen algunas ventajas significativas frente a las listas enlazada.5 Operaciones bsicas con listas doblemente enlazadas Nuevamente se tienen las mismas operaciones sobre este tipo listas:

Aadir o insertar elementos. Puede llevarse a cabo en cualquier lugar de la lista. Buscar o localizar elementos. Dada una caracterstica especial. Borrar elementos. Permite elegir el elemento a eliminar. Moverse a travs de la lista, siguiente y anterior.
Se intentar analizar algunos casos posibles de insercin, eliminacin y visualizacin de elementos en listas doblemente enlazadas. Para ampliar este tema puede consultar la siguiente direccin web: http://ldcastillo.wordpress.com/tema-2-listas-doblemente-enlazadas/ Implementacin de una lista doblemente enlazada En el siguiente listado se presenta el cdigo completo de progra30.cpp, el cual crea una lista doblemente enlazada con punteros donde se incluye un men de opciones para su interaccin, adicionalmente presenta funciones para crear la lista del registro de personas, visualiza la lista, elimina un registro y busca un registro dentro de la lista. Progra30.cpp #include <conio.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <iostream.h> struct direc { char nombre[30]; char ciudad[20]; char codigo[10]; struct direc *sig; //PUNTERO A LA SIGUIENTE ENTRADA
5
Tomado de: http://ldcastillo.wordpress.com/tema-2-listas-doblemente-enlazadas/
110
struct direc *ant; //PUNTERO AL REGISTRO ANTERIOR }; struct direc *ppio; //PUNTERO A LA PRIMERA ENTRADA ALA LISTA struct direc *final; //PUNTERO ALA ULTIMA ENTRADA struct direc *buscar(char *); void intro(void); void buscar(void); void listar(void); void eliminar(struct direc **, struct direc **); void dl_insert(struct direc *i, struct direc **ppio, struct direc **final); void leecad(char *, char *, int), mostrar(struct direc *); int menu(void); int main(void) { clrscr(); ppio = final = NULL; //INICIALIZA LOS PUNTEROS for(;;) { switch(menu()) { case 1: intro(); //INTRODUCIR UNA DIRECCION break; case 2: eliminar(&ppio, &final); //ELIMINA UNA DIRECCION break; case 3: listar();//MOSTRAR LA LISTA break; case 4: buscar();//ENCONTRAR UNA DIRECCION break; case 5: exit(0); } } }
//selecionar una operacion int menu(void) {
111
char s[80]; int c; cout<<"\nLISTA DOBLEMENTE ENLAZADA\n\n"; cout<<"1. Introducir una direccion" <<endl; cout<<"2. Eliminar una direccin" <<endl; cout<<"3. Listar el archivo" <<endl; cout<<"4. Buscar" <<endl; cout<<"5. Salir" <<endl; do { cout<<"\nIntroduce una opcion: "; gets(s); c = atoi(s); }while(c<0 || c>5); clrscr(); return c; } //Introducir nombres y direcciones void intro(void) { struct direc *info; for(;;) { info = (struct direc *)malloc(sizeof(struct direc)); if(!info) { cout<<endl <<"no hay memoria"; return; } leecad("\nIntroduce el nombre: ", info->nombre, 30); if(!info->nombre[0]) break; //parar el proceso leecad("Introduce la ciudad: ", info->ciudad, 20); leecad("Introduce el codigo: ", info->codigo, 10); dl_insert(info, &ppio, &final); } clrscr(); } 112
/* Esta funcion lee una cadena de longitud maxima cont y previene el desbordamiento de la cadena. tambien visualiza un mensaje indicativo */ void leecad(char *indic, char *s, int cont) { char p[255]; do { printf(indic); fgets(p, 254, stdin); }while(strlen(p) > cont); p[strlen(p)-1] = 0; //Eliminar el salto de linea strcpy(s, p);
// crear una lista doblemente enlazada void dl_insert( struct direc *i, //nuevo elemento struct direc **ppio, //primer elemento de la lista struct direc **final //ultimo elemento de la lista ) { struct direc *ant, *p; if(*final == NULL) //primer elemento de la lista { i->sig = NULL; i->ant = NULL; *final = i; *ppio = i; return; } p = *ppio; //principio de la lista ant = NULL; while(p) { if(strcmp(p->nombre, i->nombre) <0) {
113
} ant->sig = i; //ponerlo en el final i->sig = NULL; i->ant = ant; *final = i; } //eliminar un elemento de la lista
ant = p; p = p->sig; } else { if(p->ant) { p->ant->sig = i; i->sig = p; i->ant = p->ant; p->ant = i; *ppio = i; return; } i->sig = p; //nuevo primer elemento i->ant = NULL; p->ant = i; *ppio = i; return; }
void eliminar(struct direc **ppio, struct direc **final) { struct direc *info; char s[80]; leecad("Introduce el nombre: ", s, 30); info = buscar(s); if(info) { if(*ppio==info) { *ppio=info->sig; if(*ppio) (*ppio)->ant =NULL; else *final = NULL; } else
114
} clrscr();
{ info->ant->sig = info->sig; if(info != *final) info->sig->ant = info->ant; else *final = info->ant; } free(info); //devolver la memoria al sistema
//buscar una direccion struct direc *buscar(char *nombre) { struct direc *info; info = ppio; while(info) { if(!strcmp(nombre, info->nombre)) return info; info = info->sig; //obtener siguiente direccion } cout<<"nombre no encontrado" <<endl; } return NULL; //no encontrado
//mostrar la lista entera void listar(void) { struct direc *info; info = ppio; while(info) { mostrar(info); info = info->sig; //obtener la siguiente direccion }
115
cout<<endl <<endl;
// esta funcion imprime realmente los campos de cada direccion void mostrar(struct direc *info) { cout<<info->nombre<<"-"; cout<<info->ciudad<<"-"; cout<<info->codigo<<"-"; cout<<endl <<endl; } //buscar un nombre en la lista void buscar(void) { char nombre[40]; struct direc *info; cout<<"Introduce el nombre a encontrar: "; gets(nombre); info = buscar(nombre); if(!info) cout<<"no encontrado"; else mostrar(info); getch(); clrscr(); }
La salida en pantalla de progra30.cpp como implementacin de una lista doblemente enlazada se puede visualizar en la figura 42 que se muestra a continuacin.
116
Leccin 15: Listas circulares Las listas enlazadas no permiten a partir de un elemento acceder directamente a cualquiera de los elementos que le preceden. En cambio la lista enlazada circular o lista circular (tambin llamada listas en anillo), en lugar de almacenar un punto NULO en el campo SIG del ltimo elemento de la lista, se hace que el ltimo elemento apunte al primero o principio de la lista. Las listas circulares presentan las siguientes ventajas respecto de las listas enlazadas simples: Cada nodo de una lista circular es accesible desde cualquier otro nodo de ella. Es decir, dado un nodo se puede recorrer toda la lista completa. En una lista enlazada de forma simple slo es posible recorrerla por completo si se parte de su primer nodo. Las operaciones de concatenacin o unin y divisin de listas son ms eficaces con listas circulares.
Pero tambin se presentan algunos inconvenientes que vale la pena mencionar. Se pueden producir lazos o bucles infinitos. Una forma de evitar estos bucles infinitos es disponer de un nodo especial que se encuentre permanentemente asociado a la existencia de la lista circular. Este nodo se denomina cabecera de la lista.
117
Figura 43 Representacin grfica de una Lista Circular
El nodo cabecera puede diferenciarse de otros nodos en una de las dos formas siguientes: Puede tener un valor especial en su campo INFO que no es vlido como datos de otros elementos. Puede tener un indicador o bandera que seale cundo es nodo cabecera.
El campo de la informacin del nodo cabecera no se utiliza, lo que se seala con el sombreado de dicho campo. En una lista circular se puede considerar las siguientes situaciones: No existe elemento alguno que apunte a NULL es decir que el ltimo elemento apunta a la cabeza o al inicio de la lista. De igual manera se integra como una estructura tipo anillo. Solo se evidencia un nodo cabecera, La cabecera siempre apuntar al siguiente enlace para algn nodo y es susceptible de crear ciclos o bucles infinitos. En una estructura tipo Circular no existe algn elemento que apunte a NULL, se presenta entonces la dificultad para conocer el ltimo elemento. Sin embargo podra considerarse que como el ltimo nodo ser aquel que en su parte siguiente apunta a la cabeza y precisamente en un mtodo de bsqueda la comparacin con el nodo cabeza ser la que indique que no existen ms elementos en la lista. Se pueden identificar dos tipos de lista circulares: Listas Circulares Simplemente Enlazadas Listas Circulares Doblemente Enlazadas Una representacin grfica sera tal como se visualiza en la figura 44 y 45.
118
Figura 44 Lista circular simplemente enlazada
Figura 45 Lista circular doblemente enlazada
Una lista enlazada circularmente vaca se representa como se muestra LISTA ---------- NULL
Aadir elemento en una lista circular vaca Partiremos de que ya tenemos el nodo A para insertar y por supuesto un puntero que apunte a l, adems el puntero que define la lista, que valdr NULL:
119
Figura 46 Primer nodo de la lista circular
El proceso es muy simple, bastar con que: 1. lista apunta a nodo. 2. lista->siguiente apunte a nodo. Aadir elemento en una lista circular no vaca De nuevo partiremos de un nodo a insertar, con un puntero que apunte a l, y de una lista, en este caso, el puntero no ser nulo: Figura 47 Insercin del segundo nodo
El proceso sigue siendo muy sencillo: 1. Hacemos que nodo->siguiente apunte a lista->siguiente. 2. Despus que lista->siguiente apunte a nodo.
120
Figura 48 Nuevo nodo insertado en la lista circular
Aadir elemento en una lista circular caso general Para generalizar los dos casos anteriores, slo necesitamos aadir una operacin: 1. Si lista est vaca hacemos que lista apunte a nodo. 2. Si lista no est vaca, hacemos que: nodo->siguiente apunte a lista->siguiente. 3. Despus que lista->siguiente apunte a nodo. La implementacin de las listas circulares se puede apreciar en el siguiente listado llamado progra31.cpp. Progra31.cpp #include <stdio.h> #include <stdlib.h> typedef struct _nodo { int valor; struct _nodo *siguiente; } tipoNodo; typedef tipoNodo *pNodo; typedef tipoNodo *Lista; // Funciones con listas: void Insertar(Lista *l, int v); void Borrar(Lista *l, int v); void BorrarLista(Lista *); void MostrarLista(Lista l); int main() { Lista lista = NULL; pNodo p; 121
Insertar(&lista, 10); Insertar(&lista, 40); Insertar(&lista, 30); Insertar(&lista, 20); Insertar(&lista, 50); MostrarLista(lista); Borrar(&lista, 30); Borrar(&lista, 50); MostrarLista(lista); BorrarLista(&lista); getchar(); return 0;
void Insertar(Lista *lista, int v) { pNodo nodo; // Creamos un nodo para el nuvo valor a insertar nodo = (pNodo)malloc(sizeof(tipoNodo)); nodo->valor = v; // Si la lista est vaca, la lista ser el nuevo nodo // Si no lo est, insertamos el nuevo nodo a continuacin del apuntado // por lista if(*lista == NULL) *lista = nodo; else nodo->siguiente = (*lista)->siguiente; // En cualquier caso, cerramos la lista circular (*lista)->siguiente = nodo;
void Borrar(Lista *lista, int v) { pNodo nodo; nodo = *lista; // Hacer que lista apunte al nodo anterior al de valor v do { if((*lista)->siguiente->valor != v) *lista = (*lista)->siguiente; } while((*lista)->siguiente->valor != v && *lista != nodo); // Si existe un nodo con el valor v: if((*lista)->siguiente->valor == v) {
122
// Y si la lista slo tiene un nodo if(*lista == (*lista)->siguiente) { // Borrar toda la lista free(*lista); *lista = NULL; } else { // Si la lista tiene ms de un nodo, borrar el nodo de valor v nodo = (*lista)->siguiente; (*lista)->siguiente = nodo->siguiente; free(nodo); }
void BorrarLista(Lista *lista) { pNodo nodo; // Mientras la lista tenga ms de un nodo while((*lista)->siguiente != *lista) { // Borrar el nodo siguiente al apuntado por lista nodo = (*lista)->siguiente; (*lista)->siguiente = nodo->siguiente; free(nodo); } // Y borrar el ltimo nodo free(*lista); *lista = NULL;
void MostrarLista(Lista lista) { pNodo nodo = lista; do { printf("%d -> ", nodo->valor); nodo = nodo->siguiente; } while(nodo != lista); printf("\n");
//Fin del programa6
Tomado de: http://www.conclase.net/c/edd/index.php?cap=004c
123
El resultado en pantalla se puede visualizar en la figura 49.
124
Actividades de Autoevaluacin de la Unidad 2 Ejercicio1. Declarar funciones para realizar las desarrolladas con las estructuras de datos tipo pilas: siguientes operaciones
Una funcin que calcule el nmero de elementos de una pila p. Una funcin que elimine los ltimos n elementos apilados en una pila p si los hay. Una funcin que imprima la inversa de una pila p, es decir que el ltimo dato ingresado sea el primero en la lista de impresin. Una funcin llamada fondo que calcule el elemento del fondo de una pila p. es decir el primer elemento insertado. Ejercicio 2. Implemente una pila usando memoria dinmica con listas enlazadas. Para realizar operaciones de push y pop. Ejercicio 3. Implemente un programa para gestionar la entrega de regalos a los nios que fueron invitados a la fiesta. Los regalos se entregarn teniendo en cuenta el orden de llegada, el primero que llegue ser el primero en recibir su regalo, es importante conocer el nombre y la edad de los nios que recibieron regalos. Ejercicio 4. Implementar funciones para una estructura tipo colas as: Una funcin que calcule el ltimo elemento de una cola. Una funcin que imprima la inversa de una cola es decir que visualice en pantalla los datos en orden inverso en que fueron ingresados. Una Funcin que intercale los elementos de dos colas. Ejercicio 5. Una cola medieval se comporta como una cola ordinaria, con la nica diferencia de que los elementos almacenados en ella se dividen en dos estamentos: nobles y plebeyos. Dentro de cada estamento, los elementos deben ser atendidos en orden de llegada; pero siempre que haya nobles en la cola, stos deben ser atendidos antes que los plebeyos. Se pide: Implementar las colas medievales utilizando memoria dinmica para. aadir un elemento nuevo a una cola consultar el primer elemento de una cola
125
quitar el primer elemento de una cola consultar el nmero de nobles en una cola, consultar el nmero de plebeyos en una cola, Ejercicio 6. Implemente una lista lineal de datos de tipo numrico, con opciones de ordenar la lista en los dos sentidos, ascendente y descendente, e imprima el resultado. Ejercicio 7. Escribir un programa para el mantenimiento de notas de un grupo de alumnos usando listas. Se debe registrar el nombre del alumno y la respectiva nota y calcular el promedio del grupo, la estructura a implementar es la siguiente. struct nodo { int nota; char nombre[15]; struct nodo *siguiente; } cabeza; Ejercicio 8. Desarrolle un programa para buscar un elemento en la lista (de nmeros enteros) y borrar todas las ocurrencias de cada elemento encontrado use un men de opciones.
126
Fuentes Documentales de la Unidad 2 AGUILAR, Luis (2003). Fundamentos de programacin, algoritmos, estructura de datos y Objetos, Tercera edicin. Espaa: McGRAW-HILL. AGUILAR, Luis (200). Programacin en C++, Algoritmos, estructura de datos y Objetos. Espaa: McGRAW-HILL. AGUILAR, Luis (2003). Fundamentos de programacin, algoritmos, estructura de datos y Objetos Tercera edicin. Espaa: McGRAW-HILL. AGUILAR Luis, ZAHONERO Martnez (2004). Algoritmos y Estructuras de Datos. Una perspectiva en C. Madrid-Espaa: McGraw-Hill. BROOKSHEAR, J. Glenn (1995). Introduccin a las ciencias de la Computacin. Cuarta Edicn. Edicin Espaola: Addison-Wesley Iberoamericana. DEYTEL Y DEYTEL(1999). Como programa C++. Segunda Edicin. Mexico D.F: Prentice Hall. McGRAW-HILL. FARREL, Joyce (2000). Introduccin a la programacin lgica y diseo. Mexico D.F: Thomson. KENNETH C, Louden (2004). Lenguajes de programacin. Segunda edicin. MexicoD.F: Thomson. Salvador, Pozo (2001). Estructuras dinmicas de datos- Listas circulares. Consultado en Octubre de 2008 en http://c.conclase.net/edd/index.php?cap=004. Salvador, Pozo (2001). Estructuras dinmicas de datos- Colas. Consultado en Octubre de 2008 en http://c.conclase.net/edd/index.php?cap=003. MENDEZ, Justo (2004). Las tendencias en los lenguajes de programacin. Consultado en Noviembre de 2008 en http://www.ilustrados.com/publicaciones/EpZVVEZpyEdFpAKxjH.php. CACERES, Abdiel (2005). Estructuras de datos en C++. Consultado en Febrero 25 de 2009 en http://computacion.cs.cinvestav.mx/~acaceres/courses/estDatosCPP/ CASTILLO, Lenin (2007). Listas doblemente enlazadas. Consultado en Mayo 2 de 2009 en http://ldcastillo.wordpress.com/tema-2-listas-doblemente-enlazadas/. 127
TEJADA, Hector (2005). Asignacin dinmica de Memoria y estructuras dinmicas. Consultado en Octubre 23 de 2008 en http://www.fismat.umich.mx/mn1/manual/node10.html. RIOFRIO, Guido (2008). Estructura de datos y algoritmos. Consultado en Septiembre 10 de 2008 en http://www.youtube.com/watch?v=ohb9bjPX7Vw. SOTO, Lauro (2005). Manejo de Memoria. Consultado en Junio 23 de 2009 en http://www.programacionfacil.com/estructura_de_datos/start. Universidad de Huelva. Departamento de Tecnologas de la Informacin (DTI) (2008). TAD Lineales. Consultado en Junio 23 de 2009 en http://www.uhu.es/17207-18209/Transparencias/Tema3.pdf.
128
UNIDAD 3
Nombre de la Unidad
ESTRUCTURAS DE DATOS NO LINEALES Con el contenido de esta unidad se pretende dar un acercamiento a la programacin orientada a objetos, considerando que en adelante ser una constante para abordar el siguiente curso de programacin orientada a objetos. Se profundiza en la aplicacin que puede darse a la temtica relacionada con los tres captulos que integran la Unidad con la temtica de la teora general de rboles, rboles binarios y finalizar con la teora de grafos, respectivamente. En el captulo 7, de la Unidad se aborda el tema del modo grfico de C++, en cuanto a la configuracin del compilar y algunas pautas para el inicio. Es importante resaltar que en esta unidad se hace una recopilacin de informacin desarrollada por varios autores que se relacionan en la bibliografa, con el propsito de ampliar la temtica y brindar al estudiante mayor soporte conceptual. Al final de la unidad, se plantean una serie de actividades que buscan determinar el grado de apropiacin del conocimiento, basados en los tres momentos: Reconocimiento, Profundizacin y transferencia, que en su conjunto garantizan el aprendizaje y por ende la adquisicin de la competencia esperada en el curso. Los rboles son, sin duda, una de las estructuras de datos no lineales, empleadas en informtica, tanto para resolver problemas de hardware como de software. Los rboles de directorios son organizaciones bastante empleadas por cualquier usuario o programador de una computadora. De igual manera cumplen un buen papel en la toma de decisiones, valido como rbol de decisiones. Los rboles genealgicos y los organigramas son 129
Introduccin
Justificacin
ejemplos comunes. Entre otras aplicaciones, los rboles se emplean para analizar circuitos elctricos y para representar la estructura de frmulas matemticas, as como para organizar la informacin de bases de datos, para representar la estructura sintctica de un programa fuente en compiladores y para la toma de decisiones. Profundizar en la conceptualizacin y la aplicabilidad de la teora general de rboles, rboles binarios y gafos en la programacin estructurada. Inducir al estudiante los aspectos fundamentales y principios bsicos necesarios para abordar la programacin orientada a objetos iniciando con la programacin en modo grfico de C++. Identificar plenamente la forma de recorrer rboles binarios de bsqueda. Identificar las operaciones que se pueden realizar con rboles binarios. Conceptualizar en la forma de recorrer los grafos y su aplicabilidad en entornos reales. Captulo 1 Leccin 1 Leccin 2 Leccin 3 Leccin 4 Leccin 5 Captulo 2 Leccin 6 Leccin 7 Leccin 8 Leccin 9 Leccin 10 Captulo 3 Leccin 11 Leccin 12 Leccin 13 Leccin 14 Leccin 15 RBOLES Teora general de rboles Otros conceptos de la teora general de rboles rbol completo Estructura para la creacin de un rbol de orden tres Introduccin al Modo Grfico de C++ RBOLES BINARIOS Conceptualizacin de rboles binarios Clasificacin de los rboles binarios Formas de Recorrer un rbol Binario bol binario de bsqueda (ABB) Operaciones en ABB GRAFOS Conceptos bsicos de grafos Grafo no dirigido Representacin de los grafos Representacin mediante listas de Adyacencia Exploracin de grafos 130
Intencionalidades Formativas
CAPITULO 7: RBOLES Introduccin Los rboles a diferencia de las listas son una estructura de datos de no lineal, atendiendo ms a una estructura de tipo jerrquico. Se abordan los temas relacionados con los conceptos bsicos de rboles, incluyendo la teora general de rboles e identificando los diferentes tipos de rboles. Se presenta un apartado ampliamente desarrollado a cerca del mdo grfico de C++, donde se ilustra a travs de imgenes la configuracin del editor, las libreras grficas y el directorio donde se encuentra la interfaz grafica es decir BGI. Finalizando con un programa de aplicacin del modo grfico que muestra figuras geomtricas y texto manejando colores y rellenos. Leccin 1: Teora general de rboles Los rboles son, sin duda, una de las estructuras de datos no lineales, empleadas en informtica, tanto para resolver problemas de hardware como de software. Los rboles de directorios son organizaciones bastante empleadas por cualquier usuario o programador de una computadora. De igual manera cumplen un buen papel en la toma de decisiones, valido como rbol de decisiones. Los rboles genealgicos y los organigramas son ejemplos comunes. Entre otras aplicaciones, los rboles se emplean para analizar circuitos elctricos y para representar la estructura de frmulas matemticas, as como para organizar la informacin de bases de datos, para representar la estructura sintctica de un programa fuente en compiladores y para la toma de decisiones. Despus de haber conceptualizado la segunda unidad y haber realizado la implementacin de los programas de aplicacin con Arreglos y Apuntadores, se presenta otra alternativa para la aplicacin y conceptualizacin de los rboles se recomienda que se realice por medio del entorno grfico que hace parte del compilador de C++, de esta manera se logra un acercamiento a la programacin orientada a objetos.
131
Definicin de rboles Los rboles son estructuras de datos muy similares a las listas doblemente enlazadas, en el sentido que tienen punteros que apuntan a otros elementos, pero no tienen una estructura lgica de tipo lineal o secuencial como aquellas, sino ramificada. Tienen aspecto de rbol, de ah su nombre. Su estudio desde el punto de vista matemtico pertenece a la teora de grafos; desde el punto de vista informtico son estructuras de datos, lo que significa que cada elemento, denominado nodo u hoja, contiene un valor. Su estudio corresponde a la teora de bases de datos, y en esta terminologa, los nodos que dependen de otros se denominan hijos. Cada hoja puede tener un mximo de hijos, si no tiene ninguno se dice que es un nodo terminal. Un rbol es una estructura de datos no lineal en la que cada nodo puede apuntar a uno o varios nodos. Tambin se suele dar una definicin recursiva: un rbol es una estructura compuesta por un dato y varios rboles. Esto son definiciones simples. Una representacin grfica de los rboles se puede visualizar en la figura 50 presente a continuacin.
Figura 50 Representacin grfica de rboles
Fuente: http://www.conclase.net/c/edd/index.php?cap=006b
Leccin 2: Otros conceptos de la teora general de rboles Con relacin al tipo de nodos que hacen parte de los rboles, se identifican algunos nodos: 132
Nodo hijo: cualquiera de los nodos apuntados por uno de los nodos del rbol. En el ejemplo, 'L' y 'M' son hijos de 'G'. Nodo padre: nodo que contiene un puntero al nodo actual. En el ejemplo, el nodo 'A' es padre de 'B', 'C' y 'D'. Los rboles con los que trabajar tienen otra caracterstica importante: cada nodo slo puede ser apuntado por otro nodo, es decir, cada nodo slo tendr un padre. Esto hace que estos rboles estn fuertemente jerarquizados, y es lo que en realidad les da la apariencia de rboles. En cuanto a la posicin dentro del rbol: Nodo raz: nodo que no tiene padre. Este es el nodo que usaremos para referirnos al rbol. En el ejemplo, ese nodo es el 'A'. Nodo hoja: nodo que no tiene hijos. En el ejemplo hay varios: 'F', 'H', 'I', 'K', 'L', 'M', 'N' y 'O'. Nodo rama: aunque esta definicin apenas la usaremos, estos son los nodos que no pertenecen a ninguna de las dos categoras anteriores. En el ejemplo: 'B', 'C', 'D', 'E', 'G' y 'J'. Leccin 3: rbol completo Un rbol completo es aquel en el que en cada nodo o bien todos o ninguno de los hijos existen. Los rboles se parecen al resto de las estructuras tratadas en la unidad dos; dado un nodo cualquiera de la estructura, se puede considerar como una estructura independiente. Es decir, un nodo cualquiera puede ser considerado como la raz de un rbol completo. Existen otros conceptos que definen las caractersticas del rbol, en relacin a su tamao: Orden: es el nmero potencial de hijos que puede tener cada elemento de rbol. De este modo, se dice 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 y as sucesivamente. Grado: el nmero de hijos que tiene el elemento con ms hijos dentro del rbol. En el rbol del ejemplo en la figura 50, el grado es tres, ya que tanto 'A' como 'D' tienen tres hijos, y no existen elementos con ms de tres hijos. Nivel: se define para cada elemento del rbol como la distancia a la raz, medida en nodos. El nivel de la raz siempre ser cero y el de sus hijos uno. As 133
sucesivamente. En el ejemplo de la figura 50, el nodo 'D' tiene nivel 1, el nodo 'G' tiene nivel 2, y el nodo 'N', nivel 3. 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 raz de un rbol, tambin se puede hablar de altura de ramas. El rbol del ejemplo de la figura 50, tiene altura 3, la rama 'B' tiene altura 2, la rama 'G' tiene altura 1, la 'H' cero. Los rboles de orden dos son bastante especiales, de hecho se ampliar un poco la informacin en el siguiente captulo. Estos rboles se conocen tambin como rboles binarios. Frecuentemente, aunque tampoco es estrictamente necesario, para hacer ms fcil moverse a travs del rbol, se aade un puntero a cada nodo que apunte al nodo padre. De este modo se podr avanzar en direccin a la raz, y no slo hacia las hojas. Es importante conservar siempre el nodo Raz ya que es el nodo a partir del cual se desarrolla el rbol, si se pierde este nodo, se perder el acceso a todo el rbol. Leccin 4: Estructura para la creacin de un rbol de orden tres El nodo tpico de un rbol difiere de los nodos que se vieron en la unidad dos para el manejo de las listas, aunque slo en el nmero de nodos. A continuacin se presenta un ejemplo de nodo para crear rboles de orden tres: struct Arbol { int dato; struct Arbol *rama1; struct Arbol *rama2; struct Arbol *rama3; }; Generalizando ms se puede declarar un a constantes llamada orden que se le asigna el valor de 5: #define ORDEN 5 struct Arbol { int dato; struct Arbol *rama[ORDEN]; };
134
El movimiento a travs de rboles, salvo que se implementen punteros al nodo padre, ser siempre partiendo del nodo raz hacia un nodo hoja. Cada vez que se llegue a un nuevo nodo se podr optar por cualquiera de los nodos a los que apunta para avanzar al siguiente nodo. Un ejemplo de estructura en rbol es el sistema de directorios y ficheros de un sistema operativo. Aunque en este caso se trata de rboles con nodos de dos tipos, nodos directorio y nodos fichero, se podra considerar que los nodos hoja son ficheros y los nodos rama son directorios. Operaciones bsicas con rboles Salvo que se trabaje con algn tipo de rboles especiales, como los que se vern en el siguiente captulo es decir el captulo 8, las inserciones sern siempre en punteros de nodos hoja o en punteros libres de nodos rama. Ya que con estas estructuras no es tan fcil generalizar, existen muchas variedades de rboles. Nuevamente se tiene casi el mismo concepto de operaciones de las que se dispona con las listas enlazadas:

Aadir o insertar elementos a un rbol. Buscar o localizar elementos dentro del rbol. Borrar elementos creados en el rbol. Moverse a travs del rbol por cada uno de sus ramas. Recorrer el rbol completo.
Los algoritmos de insercin y borrado dependen en gran medida del tipo de rbol que se est implementando, de modo que por ahora se dejarn a un lado y se centrar la atencin en el modo de recorrer los rboles. rboles ordenados Los rboles ordenados son los que tienen ms inters desde el punto de vista de los tipos de datos abstractos (TAD), y los que tienen ms aplicaciones genricas. Un rbol ordenado, en general, es aquel que a partir del cual se puede obtener una secuencia ordenada siguiendo uno de los recorridos posibles del rbol, es decir en inorden, preorden o posorden. En estos rboles es importante que la secuencia se mantenga ordenada aunque se aadan o se eliminen nodos. 135
Existen varios tipos de rboles ordenados, a continuacin se presentan a nivel informativo: rboles binarios de bsqueda (ABB): son rboles de orden 2 que mantienen una secuencia ordenada si se recorren en inorden. rboles AVL: son rboles binarios de bsqueda balanceados, es decir, los niveles de cada rama para cualquier nodo no difieren en ms de 1. rboles perfectamente equilibrados: son rboles binarios de bsqueda en los que el nmero de nodos de cada rama para cualquier nodo no difieren en ms de 1. Son por lo tanto rboles AVL tambin. rboles 2-3: son rboles de orden 3, que contienen dos claves en cada nodo y que estn tambin equilibrados. Tambin generan secuencias ordenadas al recorrerlos en inorden. rboles-B: caso general de rboles 2-3, que para un orden M, contienen M-1 claves7.
Para finalizar la temtica propuesta en el presente captulo, se presenta a continuacin en la leccin 5, una introduccin a lo que es el modo grfico de C++, que ser el referente para los inicios de la programacin orientada a objetos y la aplicacin a la temtica de los captulos 8 y 9 del presente curso. Bienvenidos. Leccin 5. Introduccin al Modo Grfico de C++ Despus de haber trabajado la segunda unidad con la implementacin de estructuras dinmicas lineales con punteros, se recomienda que la tercera unidad se realice por medio del modo grfico, teniendo en cuenta que en esta unidad se har la representacin grfica de los rboles y los grafos. Configuracin del modo grafico de C++ Tal como se propone en la introduccin general del curso, para el desarrollo del lenguaje de programacin se recomienda trabajar con el compilador de Borlan C++ 3.0, la razones obedecen a que es uno de los compiladores ms completos de uso general para plataforma Linux y Windows XP en especial, ya que para Windows Vista y Windows 7 en el manejo de grficos se requiere una versin de compilador superior es por ello que para este curso se propone Borland C++ 5.5
7
Tomado de: http://www.conclase.net/c/edd/index.php?cap=006b.
136
entre tantas versiones que hay disponibles y son de fcil manejo y algo adicional que es de libre uso y ya viene configurado siempre y cuando la descarga la realice del sitio https://sites.google.com/site/hhmosquera/file-cabinet. A continuacin se muestra la interfaz grfica del compilador Borland C++ 5.5. el cual recomiendo su uso para plataforma Windows Vista y Windows 7 pues no requiere de ningn tipo de configuracin adicional ya tiene las libreras grficas. Figura 51. Interfaz grfica del compilador Borland C++ 5.5.
Se presentan algunas ventajas significativas de este compilador Borland C++ 5.5 comparado con Turbo C++ 3.0. El editor es mucho ms flexible ya que permite copiar y pegar el cdigo como se hace con cualquier aplicacin de windows, los caracteres especiales responden deacuerdo a la configuracin del idioma de su teclado, basta con compilar el programa para que se genere el ejecutable con extensin .exe que es el archivo en modo grfico a visualizar como salida en pantalla. Es importante saber que el ejecutable se crea en la misma ruta donde tiene guardado el cdigo fuente, es decir, el archivo con extensin .cpp. Para compilar el programa solo tiene que ubicar en la barra de men del compilador la opcin Tools y dar clic en la opcin Compile o presione las teclas Ctrl + F7. Para probar si qued bien instalado el compilador solo tiene que copiar en el editor el siguiente cdigo fuente: #include <graphics.h> #include <conio.h> 137
#include <stdio.h> void main(void) { int monitor=DETECT, modo; initgraph(&monitor,&modo,""); setcolor(YELLOW); line(10,50,50,100); setcolor(WHITE); circle(100,200,30); //setfillstyle(LINE_FILL,RED); floodfill(100,200,WHITE); rectangle(200,100,300,200); setfillstyle(HATCH_FILL,BLUE); floodfill(250,150,WHITE); setcolor(GREEN); settextstyle(GOTHIC_FONT,HORIZ_DIR,3); outtextxy(20,10,"Modo Grfico de C++"); outtextxy(20,250,"Hola Ingeniero esto es:"); setcolor(CYAN); outtextxy(20,300,"Estructura de datos"); getch(); closegraph(); return; } Otra alternativa para trabajar en modo grfico es el compilador de Turbo C++ 3.0, el cual requiere una configuracin bsica que se describe a continuacin. Para configurar la versin de Borland C++ 3.0 en plataforma Windows XP se procede de la siguiente manera. Se parte del hecho de que ya se tiene instalado el compilador en la ruta que se define por defecto, es decir C:\TC\BIN. Para iniciar la configuracin se debe abrir el editor creando un nuevo programa, Se debe habilitar las libreras grficas, tal como se visualiza en la figura 52. Presente a continuacin. Figura 52 Opcin para Habilitar las libreras grficas de C++.
138
Una vez haya seleccionado la opcin Libraries.. se muestra la siguiente interfaz, la cual debe sealar la opcin Graphics Library, para que quede marcada con la X y solo resta dar clic en la opcin OK y listo. Una vez habilitada las libreras grficas, solo queda por incluir la ruta donde se encuentran los archivos de la interfaz grfica binaria (BGI) que est ubicada en la ruta que trae por defecto al instalarse el programa; esa ruta es C:\TC\BGI; se procede a incluir esta ruta en la opcin de directorios tal como se muestra en la figura siguiente, Figura 53. Figura 53 Configuracin de directorio para BGI
Al dar clic en Opcions, se despliega el men que se visualiza en la imagen, seleccione Directories y lo lleva a la siguiente pantalla: Figura 54 Interfaz de directorios de C++.
En la primera lnea solo tiene que incluir la siguiente ruta tal como se ve en la siguiente grfica; C:\TC\BGI
139
Figura 55 Inclusin de la ruta C:\TC\BGI
As se ver una vez haya incluido la ruta C:\TC\BGI solo debe presionar OK y listo ya tiene configurado el compilador para trabajar en modo grfico sin problemas. Solo resta probar la configuracin del editor para modo grfico con un Hola mundo sencillo, que Grafica Figuras Geomtricas, lneas, texto, colores y rellenos. El programa incluye comentarios explicativos en cada lnea de cdigo, se sugiere que estos comentarios los elimine para evitar que pueda generarle algn tipo de error de compilacin. Progra32.cpp #include <graphics.h> // Encabezado con declaraciones de graficos #include <conio.h> #include <stdio.h> void main(void) { int monitor=DETECT, modo; // Declaracion de tipo de monitor y modo initgraph(&monitor,&modo,"C:\\tc\\bgi"); // Inicializa el modo grafico indicando el monitor y modo utilizado // El subdirectorio C:\\tc\\bgi indica la ruta de localizacion de los // archivos *.BGI (monitores) y *.CHR (tipos de letras) gotoxy(1,23);printf("getmaxx()=%d",getmaxx()); gotoxy(1,24);printf("getmaxy()=%d",getmaxy()); setcolor(YELLOW); // Establece el color amarillo para los trazos line(0,0,50,50); // Dibuja una linea desde 0,0 hasta 50,50 setcolor(WHITE); //Establece el color blanco circle(100,200,30); // Dibuja un circulo el centro est en 100,200 y de // radio=30 pixeles
140
setfillstyle(LINE_FILL,RED); // Establece el relleno de lineas rojas floodfill(100,200,WHITE); // Rellena el contorno desde 100,200 hasta // encontrar un trazo blanco rectangle(200,100,300,200); // Dibuja un rectangulo desde 200,100 hasta // 300,200 setfillstyle(HATCH_FILL,BLUE); // Establece el relleno como cuadricula floodfill(250,150,WHITE); // Rellena el contorno desde 100,200 hasta // encontrar un trazo blanco setcolor(GREEN); //Establece el color verde settextstyle(GOTHIC_FONT,HORIZ_DIR,5); // Establece el font como Gotico // en posicion Horizontal de tamano 5 outtextxy(320,100,"Ingenieros Gothic "); // Despliega el mensaje "Gothic" en 330,100 setcolor(CYAN); //Establece el color celeste //settextstyle(SANS_SERIF_FONT,VERT_DIR,2);// Establece el font como // Sanserif en posicion Vertical de tamano 7 outtextxy(300,200,"Ingenieros Sanserif");// Despliega el mensaje "Sanserif" en 330,200 getch(); closegraph(); // Termina el modo grafico (vuelve a su modo normal) return; } La salida en pantalla de progra32.cpp lo visualiza en la siguiente figura 56. Figura 56 Salida en pantalla de progra32 Modo grafico de C++.
Un ejemplo ms completo con la temtica de rboles binarios se realizar haciendo uso del modo grfico en el captulo siguiente y en los anexos 2 del mdulo.
141
CAPITULO 8: RBOLES BINARIOS Introduccin Los rboles binarios son estructuras de datos de no lineales, atendiendo ms a una estructura de tipo jerrquico. En el presente captulo se abordan los temas relacionados con los conceptos bsicos de rboles binarios, incluyendo la teora general de rboles binarios e identificando la forma de recorrerlos. As como tambin la documentacin de los rboles binarios de bsqueda y la forma de ir insertando los datos en el rbol. Se presenta un apartado amplio con el desarrollo de programas como aplicacin en mdo grfico de C++. Finalizando con un programa de aplicacin del modo grfico que muestra la creacin del rbol y la visualizacin de los recorridos.
Leccin 6: Conceptualizacin de Arboles Binarios Este tipo de rbol se caracteriza porque tienen un vrtice principal y de l se desprende dos ramas. La rama izquierda y la rama derecha a las que tambin se les conoce como subrboles.
Figura 57 Estructura de un rbol binario
La rama izquierda y la derecha, tambin son dos rboles binarios. El Vrtice principal se denomina raz y cada una de las ramas se puede denominar como subrbol izquierdo y subrbol derecho. 142
Representacin grfica de un rbol binario Figura 58 Representacin grfica de un rbol binario
La raz de este rbol es A y el rbol izquierdo est conformado por dos rboles. Uno de raz B tal como se muestra en la figura 59. Y el otro de raz I tal como se muestra en la figura 60.
Figura 59 Representacin grfica del subrbol izquierdo
Los dos subrboles tienen a su vez dos subrboles cada uno, donde C y F son la races de los arboles del sub rbol izquierdo. Mientras que las races de los subrboles del subrbol derecho son J y M respectivamente, tal como se visualiza en la figura 60.
143
Figura 60 Representacin grfica del subrbol derecho
Nodo: Un rbol binario es un conjunto de elementos cada uno de los cuales se denomina nodo. Un rbol Binario puede tener cero nodos y este caso se dice que est vaco. Puede tener un slo nodo, y en este caso solamente existe la raz del rbol o puede tener un nmero finito de nodos. Cada nodo puede estar ramificado por la izquierda o por la derecha o puede no tener ninguna ramificacin. Padre: Un Padre es un nodo que puede o no tener ramificaciones. Un ejemplo se puede visualizar en la figura 61. Figura 61 Representacin grfica de un nodo padre
En los tres casos el nodo A es un padre. En el caso 1 es un padre que no tiene hijos. En el caso 2, el nodo A es el padre del nodo B. En el caso 3 el nodo A es padre de los nodos B y C pero no es padre del nodo D. Hijo: En el ejemplo anterior. El caso 1 el nodo A no tiene hijos. En el caso 2,B es un hijo del nodo A y en caso 3, D es hijo de B y el Padre de B es el nodo A. Hermano: Nos referimos al caso 3 del ejemplo anterior. Los hermanos son los hijos de un mismo padre. Los nodos B y C son hermanos. El nodo D no tiene Hermanos. 144
Hoja: Una hoja es un nodo que no tiene ramificaciones. Por ejemplo Figura 62 Representacin grfica de un nodo hoja
El nodo C es una hoja mientras que el nodo B no se puede considerar como hoja porque tiene una ramificacin por la derecha. El nodo D tambin es una hoja. Nodo no terminal: Un nodo no terminal es aquel que posee por lo menos una ramificacin. En el ejemplo anterior, el nodo A o el nodo B son nodos no terminales, mientras el nodo D o el nodo C son nodos terminales. Camino: Un rbol siempre se examina de arriba hacia abajo. Por Ejemplo: Figura 63 Camino del rbol
Al nodo C se puede llegar desde el nodo B. Nunca se puede examinar el nodo B a partir del nodo C. Los apuntadores derecho o izquierdo de cualquier nodo apuntan al rbol derecho o izquierdo que siguen a ese nodo. Nunca apuntan a los nodos precedentes. Un Camino, es el conjunto de nodos que tenemos que visitar con el propsito de llegar a un nodo especfico. Por ejemplo para llegar al nodo F, es necesario recorrer el camino: A ------- D ------ F 145
Del mismo nodo, para llegar al nodo G debemos recorrer el camino: A ----- D ------- E ------- G Obsrvese que los Caminos se configuran siempre hacia abajo. Longitud: Longitud es el nmero de nodos que se deben recorrer para pasar de un nodo a otro. Por ejemplo: Figura 64 Longitud del rbol binario
De acuerdo a la figura 64. La longitud entre A y E es 3. La longitud entre G y G es 0. La longitud entre A y B es 1. Obsrvese que no se puede calcular la longitud entre B y G ya que el camino B ---- A ---- G no existe. Descendiente: El nodo C es descendiente del nodo A si a partir de A se puede llegar a C a travs de un camino segn la figura 64, El nodo C es descendiente de A ya que a C podemos llegar por el camino A -----B ------ C En el Ejemplo anterior, el nodo E es descendiente de D pero el nodo D no es descendiente de G. Ancestro: El nodo A es un ancestro del nodo C si existe un camino entre A y C. Basndonos en el ejemplo anterior, A es un ancestro de C ya que existe un Nivel: Cada nodo tiene un nivel dentro de un rbol binario. Por definicin el nodo raz tiene un nivel 0 y los dems nodos tienen el nivel de su padre ms 1. Por esto los nodos que son hijos del nodo raz tienen un nivel 1.
146
Figura 65 Nivel del rbol
El nodo A, tienen un nivel 0 en tanto que los nodos R y F tienen un nivel 1 Obsrvese que el nivel del nodo G es la longitud del camino desde la raz hasta el nodo y tiene nivel 3. Grado de un Nodo. El grado de un nodo es el nmero de hijos. Por ejemplo el grado del nodo A es 2, el grado del nodo T es 1. El grado de un nodo terminal siempre es 0. En los rboles binarios, el grado de un nodo flucta entre 0 y 2. Altura: La altura de un rbol binario es el nivel de la hoja o de las hojas que estn ms distantes de la raz. Basndose en la figura 65 de la grfica anterior, la altura del rbol cuya raz es A, corresponde a la longitud del camino para llegar a la hoja G que es ms distante de la raz, En este caso ser 3. Leccin 7: Clasificacin de los rboles binarios rbol Binario completo: Un rbol binario completo es aquel en el que todo nodo no terminal tiene sus dos hijos. El siguiente es un rbol binario completo de nivel 3 Figura 66 Representacin grfica de un rbol binario completo.
147
Obsrvese que todos los nodos no terminales tienen sus dos hijos. El mximo nmero de nodos que puede tener un rbol de nivel n puede representarse con la siguiente ecuacin matemtica: 2+2+2+2...+2n Si n es 3 entonces: 2+2+2+2 = 15 El rbol de la figura 66, es un rbol binario completo de nivel 3, donde el nmero mximo de nodos es 15 tal como lo indica la frmula matemtica. rbol binario Igual: Dos rboles son iguales si los dos son vacos. Existe otro caso en el cual dos rboles son iguales:
Figura 67 Representacin grfica de rbol binario igual
Estos rboles son iguales porque sus races son iguales y tambin lo son su respectivo rbol izquierdo y derecho. Para que un rbol sea igual a otro, es necesario que el contenido de cada uno de sus respectivos nodos sea el mismo y que tengan las mismas relaciones de parentesco. rbol Binario Semejante: Dos rboles binarios son semejantes si tienen el mismo nmero de nodos y los valores de los nodos del primer rbol son los mismos que los valores de los nodos del segundo, sin importar la relacin de parentesco entre ellos. Por ejemplo:
148
Figura 68 Representacin grfica de rboles semejantes
Estos rboles son semejantes. Contienen los mismos valores en cada uno de sus nodos. rbol Binario Isomorfo: Dos rboles binarios son isomorfos si tienen la misma estructura aunque el contenido de cada uno de sus nodos sea diferente. Por ejemplo los siguientes rboles son isomorfos.
Figura 69 Representacin grfica de rboles isomorfos
Peso: El peso de un rbol en un nodo dado es el nmero de nodos en el rbol sin contarse el mismo. Por ejemplo teniendo como referente los rboles de la figura 69, se tiene que el peso de cualquiera de los dos rboles cuya raz es A, corresponde al nmero de nodos para cada rbol es 6. Mientras que cualquiera de los nodos B y C tienen un peso de 2. Leccin 8: Formas de Recorrer un rbol Binario Los rboles binarios, son estructuras de datos no lineales, son considerados como estructuras jerrquicas y como tal su forma de recorrerlos difiere sustancialmente en comparacin con las listas enlazadas que son estructuras de datos de tipo 149
lineal. En ese orden de ideas, el recorrido de un rbol binario se lleva a cabo en tres sentidos: Preorden, Inorden y Postorden. A continuacin se detalla cada caso. Recorrido en Preorden Recorrer un rbol en preorden consiste en primer lugar, examinar el dato del nodo raz, posteriormente se recorrer el subrbol izquierdo en preorden y finalmente se recorre el subrbol derecho en preorden. Esto significa que para cada subrbol se debe conservar el recorrido en preorden, primero la raz, luego la parte izquierda y posteriormente la parte derecha. En la figura 70, se visualiza un rbol binario, perfectamente equilibrado, en el que sus nodos son de tipo carcter. De acuerdo con la definicin del recorrido en preorden el resultado sera: Figura 70 Recorrido del rbol binario en preorden
Otro ejemplo de recorrido en preorden, donde sus nodos son de tipo numrico para el siguiente rbol binario de la figura 71. Figura 71 Resultado del recorrido en preorden del rbol
150
Una forma de implementar los recorridos de un rbol binario es a travs de funciones especficas para dicha tarea. void preorden(tarbol *a) { if (a != NULL) { visitar(a); preorden(a->izq); preorden(a->der); } } Recorrido en Inorden Recorrer un rbol en Inorden consiste en primer lugar en recorrer el subrbol izquierdo en Inorden, luego se examina el dato del nodo raz, y finalmente se recorre el subrbol derecho en Inorden. Esto significa que para cada subrbol se debe conservar el recorrido en Inorden, es decir, primero se visita la parte izquierda, luego la raz y posteriormente la parte derecha. He aqu una aplicacin un ejemplo: Manos a la obra Se tiene el rbol binario de la figura 72, con datos de tipo numrico. El recorrido inicia con el subrbol izquierdo, el primer nodo a visitar es el 3 luego se visita el 5 y posteriormente el 7, con esto se garantiza que el recorrido del subrbol izquierdo se hizo en Inorden. Finalizado el recorrido del subrbol izquierdo se visita el nodo de la raz, que para este caso es el numero 10. Solo queda recorrer el subrbol derecho en Inorden, es decir se visita el 11 luego el 12 y se finaliza con la visita del nodo 15 El resultado completo del recorrido en Inorden para el rbol de la figura 72 es: 3 5 - 7 - 10 - 11 - 12 15 Tal como se muestra en la figura.
151
Figura 72 Representacin grfica del recorrido en Inorden
Se puede implementar el recorrido en Inorden de un rbol binario es a travs de una funcin especficas para dicha tarea. void inorden(tarbol *a) { if (a != NULL) { inorden(a->izq); visitar(a); inorden(a->der); } } Por ltimo solo queda describir la tercera forma de recorrer un rbol binario. Recorrido en Postorden Recorrer un rbol en Postorden consiste en primer lugar en recorrer el subrbol izquierdo en Postorden, luego se recorre el subrbol derecho en Postorden y finalmente se visita el nodo raz. Esto significa que para cada subrbol se debe conservar el recorrido en Postorden, es decir, primero se visita la parte izquierda, luego la parte derecha y por ltimo la raz. He aqu la aplicacin con un ejemplo basado en el rbol de la figura 72: Manos a la obra El recorrido inicia con el subrbol izquierdo, el primer nodo a visitar es el 3 luego se visita el 7 y posteriormente el 5 que es la raz, con esto se garantiza que el recorrido del subrbol izquierdo se hizo en Postorden. 152
Finalizado el recorrido del subrbol izquierdo se inicia la visita al subrbol derecho en Postorden, es decir, se visita el 11 luego el 15 y se finaliza con la visita del nodo 12 que sera la raz de este subrbol. Solo queda recorrer la raz del rbol que para este caso es el nmero 10. El resultado completo del recorrido en Postorden para el rbol de la figura 72 es: 3 - 7 - 5 - 11 - 15 12 - 10 Tal como se muestra en la siguiente figura 73.
Figura 73 Recorrido en Postorden del rbol binario.
Se puede implementar el recorrido en Postorden de un rbol binario es a travs de una funcin especficas para dicha tarea. void postorden(arbol *a) { if (a != NULL) { postorden(a->izq); postorden(a->der); visitar(a); } } Como aplicacin a los tres recorridos de un rbol binario se presenta el siguiente rbol binario de la figura 74, con datos de tipo carcter con el propsito de identificar los recorridos es Preorden, Inorden, Postorden.
153
Figura 74 rbol binario como aplicacin a los tres recorridos
El resultado que arroja al realizar los tres recorridos es el siguiente: Preorden: P Q S T R U W X V Y Z Inorden: S Q T P W U X R Y V Z Postorden: S T Q P W X U Y Z V R P
Leccin 9: bol binario de bsqueda (ABB) Los rboles binarios de bsqueda, son un tipo especial de rbol binario cuya caracterstica radica en la forma ordenada de insertar sus elementos, facilitando as la bsqueda de un nodo en particular. Para puntualizar aun ms, se tratarn los rboles binarios de bsqueda, en los que se tiene preestablecido un cierto orden, que seguramente ayudar a encontrar un cierto dato dentro de un rbol con mucha rapidez. La pregunta sera; cmo es este orden prefijado o preestablecido? La respuesta es sencilla y entenderlo es aun ms, Solo se debe cumplir la condicin que para cada nodo se tiene que:

la rama de la izquierda contendr elementos menores. la rama de la derecha contendr elementos mayores.
Tal como se ha mantenido la metodologa a lo largo del curso, un ejemplo sera la forma de explicarlo. Manos a la obra Se tienen los siguientes datos de tipo numrico para crear con ellos un rbol binario de bsqueda. 154
Los datos son: 5 3 7 2 4 8 - 9 El primer nodo siempre ser asignado a la raz del rbol binario de bsqueda, as que para este caso el 5 es la raz del rbol. 5 Primer nmero: 5 (directo) Segundo nmero: 3 se interroga (3 es menor que 5) la respuesta es s, entonces va al lado izquierdo de 5. / 5
Tercer nmero: 7 (7 es mayor que 5) se inserta al lado derecho de 5, con ello se va construyendo el rbol. / 5 \
Cuarto nmero: 2 (2 es menor que 5, y menor que 3) entonces va al lado izquierdo del 3. / 5 \
Quinto nmero: 4 (4 es menor que 5 pero es mayor que 3) entonces va al lado derecho del 3. Nada complicado. / 4 5 \
3 / \
Sexto nmero: 8 (8 es mayor que 5 y mayor que 7) en este caso se ingresa al lado derecho de 7. 155
/ \
Sptimo nmero: 9 (9 es mayor que 5 , es mayor que 7 y es mayor que 8) en este caso se ingresa al lado derecho del nmero 8 formando de esta manera el rbol binario de bsqueda. / \ 5 \
Ventajas de los rboles binarios de bsqueda Para este tipo de rbol es muy evidente la rapidez con que se podra encontrar un el valor de un nodo; para este caso se tienen 7 elementos de tipo numrico no ordenados, lo que en una lista supone que si se busca un dato que casualmente est al final, se haran 7 comparaciones; en este rbol, dado que este rbol es de altura 4, se tienen que realizar 4 comparaciones como mximo. Y si adems se hubiera equilibrado el rbol, es decir, irlo reacomodando de modo que siempre tenga la menor altura posible, habra quedado con una altura igual 3. Esto es lo que se hace en la prctica cuando en el rbol se va a hacer muchas ms lecturas que escrituras: se reordena internamente despus de aadir cada nuevo dato, de modo que la altura sea mnima en cada caso. De este modo, el nmero mximo de comparaciones que se tendran que hacer sera representado por la expresin matemtica log2(n), lo que supone que si se tienen 500 datos, en una lista se podra llegar a tener que hacer 500 comparaciones, y en un rbol binario de bsqueda, log2(1000) = 10 comparaciones como mximo. La ganancia en velocidad de bsqueda es clara. Habiendo conceptualizado la teora de un rbol binario de bsqueda, la tarea sera desarrollar un programa en modo grfico de C++ para que al insertar los datos ingresados por teclado en tiempo de ejecucin, se imprima en pantalla la grfica del rbol binario de bsqueda. 156
Leccin 10: Operaciones en ABB Las operaciones que se pueden realizar sobre un rbol binario de bsqueda ABB es parecido al que se realizan sobre otras estructuras de datos lineales, ms alguna otra propia de rboles entre ellas estn: Buscar un elemento en cualquier posicin del rbol Insertar un elemento en cualquier lugar del rbol Borrar un elemento ubicado en cualquier lugar del rbol. Movimientos a travs del rbol: Izquierda. Derecha. Raz.
Borrar un nodo rama con intercambio de un nodo hoja En el rbol de ejemplo, representado en la figura 74, borrar el nodo 4. 1. Se localiza el nodo a borrar ('raz'). 2. Se busca el nodo ms a la derecha del rbol izquierdo de 'raz', en este caso el 3, al tiempo que se mantiene un puntero a 'Padre' a 'nodo'. 3. Se Intercambian los elementos 3 y 4. 4. Se hace que el puntero de 'Padre' que apuntaba a 'nodo', ahora apunte a NULL. 5. Se borra el 'nodo'. Figura 75 Borrado de un nodo rama con intercambio de nodo hoja
Fuente: http://www.conclase.net/c/edd/index.php?cap=007 Borrar un nodo rama con intercambio de un nodo rama Para este ejemplo se tiene otro rbol. En ste se borrar el elemento 6.
157
Figura 76 Representacin grfica de un rbol binario de bsqueda
Fuente: http://www.conclase.net/c/edd/index.php?cap=007 1. Se localiza el nodo a borrar ('raz'). 2. Se busca el nodo ms a la izquierda del rbol derecho de 'raz', en este caso el 12, ya que el rbol derecho no tiene nodos a su izquierda, si se opta por la rama izquierda, se estar en un caso anlogo. Al mismo tiempo que se mantiene un puntero a 'Padre' a 'nodo'. 3. Se intercambia los elementos 6 y 12. 4. Ahora se tiene que repetir el bucle para el nodo 6 de nuevo, ya que no es posible eliminarlo. Figura 77 Borrado de un nodo rama con intercambio de nodo rama
Fuente: http://www.conclase.net/c/edd/index.php?cap=007 5. Se localiza de nuevo el nodo a borrar ('raz'). 6. Se busca el nodo ms a la izquierda del rbol derecho de 'raz', en este caso el 16, al mismo tiempo que se mantiene un puntero a 'Padre' a 'nodo'. 7. Se hace el intercambio de los elementos 6 y 16. 158
8. Se hace que el puntero de 'Padre' que apuntaba a 'nodo', ahora apunte a NULL. 9. Se procede a borrar el 'nodo'. Figura 78 Intercambio de un nodo rama con intercambio de nodo rama
Fuente: http://www.conclase.net/c/edd/index.php?cap=007 Este modo de actuar asegura que el rbol sigue siendo ABB8. Implementacin de un rbol binario con Punteros Progra34.cpp #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <ctype.h> #include <iostream.h> struct arbol { int dato; struct arbol *izq; struct arbol *der; }*raiz; enum{ FALSO=0, VERDADERO }; /*PROTOTIPOS*/
8
Tomado de: http://ldcastillo.wordpress.com/tema-4-arboles-binarios/
159
void inicializar( void ); int vacio( struct arbol *hoja ); int eshoja( struct arbol *hoja ); struct arbol *insertar( struct arbol *raiz, struct arbol *hoja, int num ); int busqueda( struct arbol *hoja, int num ); int nodos( struct arbol *hoja ); void auxnodos( struct arbol *hoja, int *cont ); struct arbol *borrarx( struct arbol *hoja, int num ); struct arbol *podar( struct arbol *hoja ); void preorden( struct arbol *hoja ); void inorden( struct arbol *hoja ); void posorden( struct arbol *hoja ); void menu_recorridos( void ); void menu_busquedas( void ); void menu_nodos( void ); void menu_podar( void ); void inicializar( void ) { raiz= NULL; } int vacio( struct arbol *hoja ) { if( !hoja ) return VERDADERO; return FALSO; } int eshoja( struct arbol *hoja ) { if( hoja->izq==NULL && hoja->der==NULL ) return VERDADERO; return FALSO; } struct arbol *insertar( struct arbol *raiz, struct arbol *hoja, int num ) { if( !hoja ) { hoja= (struct arbol *) malloc( sizeof (struct arbol) ); hoja->dato= num; hoja->izq= NULL; hoja->der= NULL; if( !raiz ) return hoja; else if( num<raiz->dato ) raiz->izq= hoja;
160
else raiz->der= hoja; return hoja; } else if( num<hoja->dato ) insertar( hoja, hoja->izq, num ); else insertar( hoja, hoja->der, num ); return raiz; } int busqueda( struct arbol *hoja, int num ) { while( hoja ) { if( num==hoja->dato ) return VERDADERO; else { if( num<hoja->dato ) hoja= hoja->izq; else hoja= hoja->der; } } return FALSO; } int nodos( struct arbol *hoja ) { int nodos=0; auxnodos( hoja, &nodos ); return nodos; } void auxnodos( struct arbol *hoja, int *cont ) { if( !hoja ) return; (*cont)++; auxnodos( hoja->izq, cont ); auxnodos( hoja->der, cont ); } struct arbol *borrarx( struct arbol *hoja, int num ) { if( hoja->dato==num ) { struct arbol *p, *p2; 161
if( vacio( hoja ) ) { free( hoja ); hoja= NULL; return hoja; } else if( hoja->izq==NULL ) { p= hoja->der; free( hoja ); return p; } else if( hoja->der==NULL ) { p= hoja->izq; free( hoja ); return p; } else { p= hoja->der; p2= hoja->der; while( p->izq ) p= p->izq; p->izq= hoja->izq; free( hoja ); return p2; } } else if( num<hoja->dato ) hoja->izq= borrarx( hoja->izq, num ); else hoja->der= borrarx( hoja->der, num ); return hoja; } struct arbol *podar( struct arbol *hoja ) { if( !hoja ) return hoja; podar( hoja->izq ); podar( hoja->der ); free( hoja ); hoja= NULL; return hoja; }
162
/*Recorridos*/ void preorden( struct arbol *hoja ) { if( !hoja ) return; cout << hoja->dato ; preorden( hoja->izq ); preorden( hoja->der ); } void inorden( struct arbol *hoja ) { if( !hoja ) return; inorden( hoja->izq ); cout <<hoja->dato ; inorden( hoja->der ); } void posorden( struct arbol *hoja ) { if( !hoja ) return; posorden( hoja->izq ); posorden( hoja->der ); cout <<hoja->dato ; } /*Menus del Arbol*/ void menu_recorridos( void ) { char _op='S'; while( _op!='4' ) { clrscr(); cout << "1. PreOrden." ; cout << "\n2. InOrden." ; cout << "\n3. PosOrden." ; cout << "\n4. Salir." ; cout << "\n\n:: " ; _op= getch(); switch( _op ) { case '1':
163
} return; }
preorden( raiz ); getch(); break; case '2': inorden( raiz ); getch(); break; case '3': posorden( raiz ); getch(); break; }
void menu_busquedas( void ) { int val; cout << "\n\nNumero: " ; cin>> val ; if( busqueda( raiz, val ) ) cout << "\n\nEncontrado.." ; else cout << "\n\nError, No se encuentra." ; getch(); } void menu_nodos( void ) { cout << "\n\nEl Numero de Nodos es " << nodos( raiz ) ; getch(); } void menu_podar( void ) { char _op='A'; int val; while( _op!='3' ) { clrscr(); cout << "1. Podar Un Nodos del Arbol." ; cout << "\n2. Podar Todo el Arbol." ;
164
cout << "\n3. Salir." ; _op= getch(); switch( _op ) { case '1': cout << "\n\nNumero: " ; cin>> val ; raiz= borrarx( raiz, val ); cout << "\n\n.... Borrado ...." ; break; case '2': raiz= podar( raiz ); cout << "\n\nArbol Borrado por Completo." ; getch(); break; } } return; } int main() { char _op='A'; int val; inicializar(); while( _op!='S' ) { clrscr(); cout << "IMPLEMENTACION DE UN ARBOL BINARIO \n\n"; cout << "Insertar" ; cout << "\nRecorridos" ; cout << "\nBusquedas" ; cout << "\nNodos" ; cout << "\nPodar" ; cout << "\nSalir" ; cout << "\n\n Ingrese la Opcion : " ; _op= toupper( getch() ); switch( _op ) { case 'I': cout << "\n\nNumero: " ; cin>> val ; if( busqueda( raiz, val ) )
165
{ cout << "\n\nEste numero ya ha sido insertado." ; getch(); break; } raiz= insertar( raiz, raiz, val ); break; case 'R': if( vacio( raiz ) ) { cout << "\n\nEl Arbol Aun esta Vacio." ; getch(); break; } menu_recorridos(); break; case 'B': if( vacio( raiz ) ) { cout << "\n\nEl Arbol Aun esta Vacio." ; getch(); break; } menu_busquedas(); break; case 'A': if( vacio( raiz ) ) { cout << "\n\nEl Arbol Aun esta Vacio." ; getch(); break; } case 'N': if( vacio( raiz ) ) { cout << "\n\nEl Arbol Aun esta Vacio." ; getch(); break; } menu_nodos(); break; case 'P': if( vacio( raiz ) ) { cout << "\n\nEl Arbol Aun esta Vacio." ;
166
} } cout << "\n\nPulsa para salir..." ; getchar(); return 0; } El resultado despus de la compilacin y ejecucin del listado, se puede visualizar en la figura 79 que se muestra a continuacin. Figura 79 Salida en pantalla de progra34
getch(); break; } menu_podar(); break;
Despues de haber profundizado en la temtica de la unida tres relacionada con la teora de rboles, rboles binarios y haber hecho una introduccin al entorno grfico de C++, solo resta presentar un programa completo funcional donde se de aplicabilidad a la teora de rboles haciendo buen uso del modo grfico. Implementacin de los rboles binarios en modo grfico El siguiente programa llamado progra35, fue realizado por Carlos Javier Guzmn, estudiante del programa de Ingeniera de Sistemas de la UNAD en el CEAD de Popayn Progra35.cpp //Autor: Carlos Javier Guzmn //Estudiante de Ingeniera de Sistemas del CEAD de Popayn #include <graphics.h> #include <iostream.h> #include <string.h> 167
#include <dos.h> #include <conio.h> #include <stdlib.h> void cajadetexto_a(int x,int y,int ancho,int altura); int iniciagrafica(); int linea_iz(int tx, int px1, int py1, int ty, int px2, int py2); int linea_der(int tx, int px1, int py1, int ty, int px2, int py2); int presentacion(); int ordenar(); int texto(); //para textos int verificar(int z); //analiza cuando hijos pueden haber main() { // int z; iniciagrafica(); setbkcolor(DARKGRAY); //color de fondo de pantalla setfillstyle(SOLID_FILL,LIGHTGRAY); //fondo de la ventana grande bar3d(620,470,5,20,10,30);//x/y/px1/py1/an //ventana grande presentacion(); cajadetexto_a(280,30,30,30);//px,py,largo,ancho A outtextxy(292,42,"A"); ordenar(); getch(); } int iniciagrafica() { int gdriver = DETECT, gmode, errorcode; initgraph(&gdriver, &gmode, "c:\\tc\\bgi"); } int ordenar() { int A,B,D,G,C,M,P,x; texto(); //llama la caja de texto outtextxy(55,388,"Cuandos hijos tiene A "); gotoxy(31,25); 168
cin>>x; texto();// llama caja de texto para no spbrescribir A=verificar(x); if(A==1 || A==2) //B { //comienza lado izquierdo setcolor(5); linea_iz(125,276,40, 55,150,39);//izquierdo entre b y a cajadetexto_a(137,100,30,30);//px,py,largo,ancho isz 5.1 B outtextxy(150,110,"B"); //b if(A==2) { setcolor(13); linea_der(145,307,40, 55,452,39);//izquierdo entre c y a cajadetexto_a(439,100,30,30);//px,py,largo,ancho derecha 5.3 C outtextxy(452,110,"C"); } outtextxy(55,388,"Cuandos hijos tiene B "); gotoxy(31,25); cin>>x; texto();// llama caja de texto para no spbrescribir B=verificar(x); if(B==1); { setcolor(5); linea_iz(60,133,110, 75,72,109); //izquierda entre d y b cajadetexto_a(60,190,30,30);//px,py,largo,ancho iszquierda 1 D outtextxy(73,200,"D"); //D } if(B==2) //D y G { setcolor(5); linea_iz(60,133,110, 75,72,109); //izquierda entre d y b cajadetexto_a(60,190,30,30);//px,py,largo,ancho iszquierda 1 D outtextxy(73,200,"D"); // D setcolor(5); linea_der(57,164,110, 75,220,109);//izquierdo entre g y b cajadetexto_a(207,190,30,30);//px,py,largo,ancho iszquierda 2 G 169
outtextxy(220,200,"G"); //G } outtextxy(55,388,"Cuandos hijos tiene D "); gotoxy(31,25); cin>>x; texto();// llama caja de texto para no sobrescribir D=verificar(x); if(D==1)//D { setcolor(5); linea_iz(34,55,198, 55,22,198); //izquierda entre e y d cajadetexto_a(10,250,30,30);//px,py,largo,ancho iszquierda 1.1 E outtextxy(23,263,"E"); } if(D==2) //E Y F { setcolor(5); linea_iz(34,55,198, 55,22,198); //izquierda entre e y d cajadetexto_a(10,250,30,30);//px,py,largo,ancho iszquierda 1.1 E outtextxy(23,263,"E"); setcolor(5); linea_der(28,87,198, 55,114,197);//izquierdo entre f y d cajadetexto_a(100,250,30,30);//px,py,largo,ancho iszquierda 1.2 F outtextxy(113,263,"F"); } if(B==2) { outtextxy(55,388,"Cuandos hijos tiene G "); gotoxy(31,25); cin>>x; texto();// llama caja de texto para no sobrescribir G=verificar(x); if(G==1) //H { setcolor(5); linea_iz(30,203,199, 45,173,199); //izquierda entre h y g cajadetexto_a(160,250,30,30);//px,py,largo,ancho iszquierda 2.1 H outtextxy(173,263,"H"); setcolor(5); 170
} if(G==2) // H y I { setcolor(5); linea_iz(30,203,199, 45,173,199); //izquierda entre h y g cajadetexto_a(160,250,30,30);//px,py,largo,ancho iszquierda 2.1 H outtextxy(173,263,"H"); setcolor(5); linea_der(28,234,199, 47,261,198);//izquierdo entre i y g cajadetexto_a(250,250,30,30);//px,py,largo,ancho iszquierda 2.2 I outtextxy(263,263,"I"); } } } //termina lado izquierdo if(A==2) { outtextxy(55,388,"Cuandos hijos tiene C "); gotoxy(31,25); cin>>x; texto();// llama caja de texto para no sobrescribir C=verificar(x); if(C==1) { setcolor(13); linea_der(55,466,110, 75,520,109);//izquierdo entre c y p setcolor(13); cajadetexto_a(510,190,30,30);//px,py,largo,ancho derecha 4 P outtextxy(522,200,"P"); } if(C==2) { setcolor(13); linea_iz(57,435,110, 75,378,109); //izquierda entre m y c setcolor(13); cajadetexto_a(367,190,30,30);//px,py,largo,ancho dercha 3 M outtextxy(379,200,"M"); setcolor(13); linea_der(55,466,110, 75,520,109);//izquierdo entre c y p 171
setcolor(13); cajadetexto_a(510,190,30,30);//px,py,largo,ancho derecha 4 P outtextxy(522,200,"P"); } outtextxy(55,388,"Cuandos hijos tiene P "); gotoxy(31,25); cin>>x; texto();// llama caja de texto para no sobrescribir P=verificar(x); if(P==1) { setcolor(13); linea_der(28,537,199, 47,564,198);//izquierdo entre z y p cajadetexto_a(550,250,30,30);//px,py,largo,ancho derecha 4.2 Z outtextxy(563,263,"Z"); } if(P==2) { setcolor(13); linea_iz(25,506,199, 45,482,199); //izquierda entre q y p cajadetexto_a(470,250,30,30);//px,py,largo,ancho derecha 4.1 Q outtextxy(482,263,"Q"); setcolor(13); linea_der(28,537,199, 47,564,198);//izquierdo entre z y p cajadetexto_a(550,250,30,30);//px,py,largo,ancho derecha 4.2 Z outtextxy(563,263,"Z"); } if(C==2) { outtextxy(55,388,"Cuandos hijos tiene M "); gotoxy(31,25); cin>>x; texto();// llama caja de texto para no sobrescribir M=verificar(x); if(M==1) { setcolor(13); linea_iz(33,364,199, 45,332,199); //izquierda entre n y m cajadetexto_a(320,250,30,30);//px,py,largo,ancho derecha 3.1 N 172
outtextxy(332,263,"N"); } if(M==2) { setcolor(13); linea_iz(33,364,199, 45,332,199); //izquierda entre n y m cajadetexto_a(320,250,30,30);//px,py,largo,ancho derecha 3.1 N outtextxy(332,263,"N"); setcolor(13); linea_der(28,394,199, 47,422,198);//izquierdo entre o y m cajadetexto_a(410,250,30,30);//px,py,largo,ancho derecha 3.2 O outtextxy(422,263,"O"); } } } //termina A=2 }//termina funcion ordenar void cajadetexto_a(int x,int y,int ancho,int altura) { setcolor(DARKGRAY); line(x,y,x+ancho-1,y); //linea superior gris oscuro line(x,y,x,y+altura-1);//linea inferior derecha gris oscuro setcolor(LIGHTGRAY); line(x+1,y+altura-1,x+ancho-1,y+altura-1); //linea inferior gris line(x+ancho-1,y+1,x+ancho-1,y+altura-1); //linea derecha gris setcolor(WHITE); line(x,y+altura,x+ancho,y+altura); //linea inferior blanco externo line(x+ancho,y,x+ancho,y+altura); //linea derescha blanco externo setfillstyle(SOLID_FILL,9); bar(x+1,y+1,x+ancho-2,y+altura-2); //pinta el cuadro de blanco } int linea_iz(int tx, int px1, int py1, int ty, int px2, int py2) { for(int i=1; i<tx; i++) { outtextxy(px1-i,py1,"."); delay(15); } 173
for(i=1; i<ty; i++) { outtextxy(px2,i+py2,"."); delay(15); } } int linea_der(int tx, int px1, int py1, int ty, int px2, int py2) { for(int i=1; i<tx; i++) { outtextxy(px1+i,py1,"."); delay(15); } for(i=1; i<ty; i++) { outtextxy(px2,i+py2,"."); delay(15); } } int presentacion() { cajadetexto_a(12,25,130,30);//px,py,largo,ancho A cuadro de mensaje arbo cajadetexto_a(482,25,130,30);//px,py,largo,ancho A cuadro de mensaje carlos sleep(1); setcolor(11); outtextxy(15,32,"Arboles"); sleep(1); outtextxy(68,44,"Binarios"); sleep(1); setcolor(11); outtextxy(495,32,"Carlos Javier"); sleep(1); outtextxy(524,44,"Guzman"); } int texto() { 174
cajadetexto_a(50,375,180,30);//px,py,largo,ancho A cajadetexto_a(230,375,30,30);//px,py,largo,ancho A } int verificar(int z) { int n,d; n=z; while(n<=0 || n>=3) { outtextxy(60,386,"Dato errado, ingrese "); outtextxy(64,393,"otro dato "); gotoxy(31,25); cin>>n; texto();// llama caja de texto para no sobrescribir } if(n==1 || n==2) { return n; } return n; } Actividad de verificacin Como actividad de verificacin, se propone que cada estudiante de forma individual, analice el cdigo que se presenta en el anterior programa en el listado llamado progra35, con el fin de que lo edite y lo lleve al compilador para ver la salida en pantalla, el cual pone en prctica los conocimientos adquiridos en la temtica de rboles binarios, en la ejecucin del programa.
175
CAPITULO 3: GRAFOS Introduccin Los grafos al igual que los rboles son estructuras de datos de no lineales, semejada a una estructura de tipo jerrquico. En el presente captulo se abordan los temas relacionados con los conceptos bsicos de grafos, incluyendo la teora general de grafos e identificando la forma de recorrerlos. As como tambin la documentacin de los tipos de grafos y la representacin a travs de matriz de adyacencia y de listas de adyacencia especialmente. Al final del captulo se propone como actividad de veririficacin un programa de aplicacin al modo grfico de C++. Donde se evidencie la creacin del grafo, la interaccin de los recorridos y la visualizacin del rbol en pantalla. Leccin 11: Conceptos bsicos de grafos Los grafos son una de las herramientas ms empleadas en matemticas, estadstica, investigacin operativa y en numerosos campos cientficos. El estudio de la teora de grafos se realiza fundamentalmente como elemento de Matemtica discreta o Matemtica aplicada. El conocimiento profundo de la teora de grafos junto con los algoritmos de implementacin es fundamental para conseguir el mayor rendimiento de las operaciones con datos, sobre todo si stos son complejos en su organizacin. Un programador de alto nivel no puede dejar de conocer en toda su profundidad la teora de grafos y sus operaciones, que adems le servir de bse para enfrentase a los cursos de investigacin de operaciones, donde se conceptualizar de una manera matematica lo referente e este tema La teora de grafos es una rama de la matemtica combinatoria muy til en la solucin de muchos problemas prcticos que se formulan de manera natural por medio de objetos y sus conexiones entre ellos (determinar el camino ms corto entre dos ciudades, anlisis de circuitos elctricos, ordenacin de tareas). En este captulo se hace la implementacin de los grafos como representacin grfica como aplicacin a la fundamentacin terica. Se recomienda que se realice por medio del entorno grfico que nos presenta el compilador de C++, de esta manera se hace un acercamiento a la programacin orientada a objetos.
176
Definicin grafos Un grafo es un objeto matemtico conformado por una coleccin de vrtices (o nodos) y aristas que se encargan de conectar o unir los. Los vrtices son objetos simples que pueden tener un nombre y otras propiedades es decir informacin y una arista que es la conexin entre dos vrtices. Representacin grafica de los Grafos Los grafos pueden ser representados en situaciones de la vida prctica, para el caso de la figura 80, representa una red de aeropuertos entre algunas ciudades de colombia. Figura 80 Representacin grfica de los grafos
A continuacin se presentan algunas definiciones bsicas de la teora de grafos. Vrtices: un vrtice tambin llamado nodo es la unidad fundamental de la conformacin de los grafos, en la figura 80, los vrtices representan las ciudades. Aristas: son consideradas las uniones entre los nodos o vrtices, vase la primera figura 80, donde las aristas representan la unin entre ciudades. Generalmente las aristas denotan relaciones entre los vrtices. Las aristas, junto con los vrtices forman los elementos principales de un grafo. Grafo dirigido (Red): Un grafo dirigido G consiste de un conjunto V de vrtices y un conjunto E de aristas del grafo un no dirigido est formado por un conjunto de vrtices y un conjunto de aristas (pares no ordenados de vrtices), mientras que un grafo dirigido est compuesto por un conjunto de vrtices y un conjunto de arcos. Un ejemplo prctico de grafo dirigido lo constituye la red del acueducto de una ciudad, ya que cada tubera slo admite que el agua la recorra en un nico sentido. Mientras que un ejemplo prctico para un grafo no dirigido lo representa 177
la red de carreteras de un pas, puesto que una misma carretera puede ser recorrida en ambos sentidos. Representacin grfica de un grafo dirigido La siguiente figura 81, muestra la representacin de un grafo dirigido. Figura 81 Representacin grfica de un grfo dirigido
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276
Leccin 12: Grafo no dirigido Sea G un grafo no dirigido donde G =(V,E) donde V corresponde al conjunto de vrtices y E el conjunto de aristas del grafo, un grafo no dirigido se diferencia de un grafo dirigido porque cada arista en E es un par no ordenado de vrtices. Cuando no importa la direccin de una arista, el grafo se denomina no dirigido lo muestra la figura 82. Una aplicacin de los grafos no dirigidos, es la red de computadoras de una empresa, en donde los vrtices estn representados en las terminales de los computadores y las ariatasn son el cabeado o en su defecto la coneccin inhalambrica. En ese sentido la informacin de la red se da en ambos sentidos al enviar y recibir informacin de cada terminal. Figura 82 Representacin grfica de un grafo no dirigido
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276 178
Costos: Los enlaces tanto para los grafos dirigidos como para los grafos no dirigidos tienen un peso, costo o valor, por lo que se conocen como grafos etiquetados. Para ampliar este concepto se puede visualizar la figura 83. Que se muestra a continuacin. Figura 83 Representacin grfica de grafos etiquetados
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276
En general el trmino grafo hace referencia a un grafo no dirigido, a menos que se especifique lo contrario. Camino: Es la secuencia o ruta de un vrtice inicial a un vrtice final. El nmero de aristas de un camino (ciclo) se denomina longitud de camino (ciclo). Un camino es simple si slo pasa una sola vez por cada nodo. La longitud del camino: es el nmero de arcos que comprende y en el caso en el que el grafo sea ponderado se calcular como la suma de los pesos de las aristas que lo constituyen. Figura 84 Representacin grfica de la longitud del camino de un grafo
Con base en la figura 84 que representa un grafo no dirigido se puede extrapolar la siguiente informacin relacionada con el camino. 179
Un camino simple de a a f = {a,b}, {b,c}, {c,f} Un camino simple de a a f = {a,b}, {b,c}, {c,e}, {e,d}, {d,c}, {c,f} Un ciclo simple: {a,b}, {b,d}, {d,a} Un ciclo no simple: {a,b}, {b,d}, {d,c}, {c,e}, {e,d}, {d,a} Grafo Conexo: Sea G = (V, E) un grafo no dirigido, entonces G es conexo si existe un camino entre cada par de vrtices de G. Por otra parte, sea G un grafo dirigido, y sea G su grafo no dirigido asociado, entonces si G es conexo, G se considera conexo. Grafos Completos: es aquel con una arista entre cada par de vrtices, es decir un grafo con todas las aristas posibles. Por otra parte, se denominan grafos densos aquellos que tienen muchas aristas. Grafos Ponderados: Se le asignan pesos a las aristas para representar la distancia o el costo asociado a pasar por dicha arista. Grafo nulo: Se dice que un grafo es nulo cuando los vrtices que lo componen no estn conectados, esto es, que son vrtices aislados. Grafos Isomorfos: Dos grafos son isomorfos cuando existe una correspondencia biunvoca (uno a uno), entre sus vrtices de tal forma que dos de estos quedan unidos por una arista en comn.
Leccin 13: Representacin de los grafos Los grafos independientemente de que sean Dirigidos o no dirigidos, pueden ser representados mediante tres formas: Matriz de adyacencia Lista de adyacencia Arreglos para listas de adyacencias
Se tiene el siguiente grafo dirigido, representado por el conjunto V, integrado por los elemento 1,2,3,4. Matemticamente representado por: V = {1,2,3,4} E = {(1,2),(2,3),(3,1), ((4,2),(3,4)}
180
Figura 85 Grafo dirigido
http://www.slideshare.net/pilypardo/grafos-1407276 Representacin por Matriz de Adyacencia La forma ms fcil de guardar la informacin de los nodos es mediante la utilizacin de un vector que indexe los nodos, de manera que los arcos entre los nodos se pueden ver como relaciones entre los ndices. Esta relacin entre ndices se puede guardar en una matriz, que llamaremos de adyacencia. La matriz de adyacencia A de un grafo G=(V,E) tiene V*V elementos la cual se define matemticamente como : A[ i , j ] = {1 si (i , j) E y 0 en cualquier otro caso} Figura 86 Representacin grfica de la matriz de adyacencia
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276 Cuando se trata de grafos ponderados en lugar de 1 el valor que tomar ser el peso de la arista. Si el grafo es no dirigido hay que asegurarse de que se marca con un 1 (o con el 181
peso) tanto la entrada a[i][j] como la entrada a[j][i], puesto que se puede recorrer en ambos sentidos. int V,A; int a[maxV][maxV]; void inicializar() { int i,x,y,p; char v1,v2; // Leer V y A memset(a,0,sizeof(a)); for (i=1; i<=A; i++) { Cout <<"\n" <<v1 <<v2 <<p; x=v1-'A'; y=v2-'A'; a[x][y]=p; a[y][x]=p; } } En esta implementacin se ha supuesto que los vrtices se nombran con una letra mayscula y no hay errores en la entrada. Evidentemente, cada problema tendr una forma de entrada distinta y la inicializacin ser conveniente adaptarla a cada situacin. En todo caso, esta operacin es sencilla si el nmero de nodos es pequeo. Si, por el contrario, la entrada fuese muy grande se pueden almacenar los nombres de nodos en un rbol binario de bsqueda o utilizar una tabla de dispersin, asignando un entero a cada nodo, que ser el utilizado en la matriz de adyacencia. Como se puede apreciar, la matriz de adyacencia siempre ocupa un espacio de V*V, es decir, depende solamente del nmero de nodos y no del de aristas, por lo que ser til para representar grafos densos9. A la matriz de adyacencia se le pueden considerar algunas ventajas y desventajas. Ventajas de la matriz de adyacencia Se puede determinar en un tiempo fijo si y constante, si un enlace (arco) pertenece o no al grafo. Es fcil determinar si existe o no un arco o enlace, solo se debe posicionar en la matriz.
9
Tomado de: http://www.algoritmia.net/articles.php?id=18
182
Es fcil determinar si existe un ciclo en el grafo, solo basta con multiplicar la matriz por ella mismo n veces hasta obtener la matriz nula (no hat ciclos) o bien una sucesin periodica de matrices (hay ciclo). Desventajas de la matriz de adyacencia Se requiere un almacenamiento |v|*|v|. Es decir O(n2). Solo al leer o examinar la matriz puede llevar un tiempo de O(n 2). Leccin 14: Representacin mediante listas de Adyacencia En las listas de adyacencia para un vrtice v es unas listas enlazadas de todos los vrtices w adyacentes a v. Un grafo puede estar representado por un |v|, listas de adyacencia, una para cada vrtice. Figura 87 Representacin grfica de un grafo por lista de adyacencia
Fuente: http://www.slideshare.net/pilypardo/grafos-1407276 En las listas de adyacencia lo que se haga ser guardado por cada nodo, adems de la informacin que pueda contener el propio nodo, una lista dinmica con los nodos a los que se puede acceder desde l. La informacin de los nodos se puede guardar en un vector, al igual que antes, o en otra lista dinmica. Las listas de adyacencia sern estructuras que contendrn un valor entero (el nmero que identifica al nodo destino), as como otro entero que indica el coste en el caso de que el grafo sea ponderado. En el ejemplo siguiente se ha utilizado una estructura con un nodo z ficticio en la cola. struct nodo { int v; 183
int p; nodo *sig; }; int V,A; // vrtices y aristas del grafo struct nodo *a[maxV], *z; void inicializar() { int i,x,y,peso; char v1,v2; struct nodo *t; z=(struct nodo *)malloc(sizeof(struct nodo)); z->sig=z; for (i=0; i<V; i++) a[i]=z; for (i=0; i<A; i++) { cout <<\n" <<v1<<v2<<peso; x=v1-'A'; y=v2-'A'; t=(struct nodo *)malloc(sizeof(struct nodo)); t->v=y; t->p=peso; t->sig=a[x]; a[x]=t; t=(struct nodo *)malloc(sizeof(struct nodo)); t->v=x; t->p=peso; t->sig=a[y]; a[y]=t; } } En este caso el espacio ocupado es O(V + A), muy distinto del necesario en la matriz de adyacencia, que era de O(V2). La representacin por listas de adyacencia, por tanto, ser ms adecuada para grafos dispersos. Hay que tener en cuenta un aspecto importante y es que la implementacin con listas enlazadas determina fuertemente el tratamiento del grafo posterior. Como se puede ver en el cdigo, los nodos se van aadiendo a las listas segn se leen las aristas, por lo que nos encontramos que un mismo grafo con un orden distinto de las aristas en la entrada producir listas de adyacencia diferentes y por ello el orden en que los nodos se procesen variar. Una consecuencia de esto es que si un problema tiene varias soluciones la primera que se encuentre depender de la entrada dada. Podra presentarse el caso de tener varias soluciones y tener que mostrarlas siguiendo un determinado orden. Ante una situacin as podra ser muy conveniente modificar la forma de meter los nodos en la lista (por ejemplo, hacerlo al final y no al principio, o incluso 184
insertarlo en una posicin adecuada), de manera que el algoritmo mismo diera las soluciones ya ordenadas10. Al igual que la matriz de adyacencia, las listas de adyacencias tambin presentan algunas ventajas y desventajas. Ventajas de las listas de adyacencia La lista de adyacencia requiere un espacio proporcional a la suma del nmero de vrtices, ms el nmero de enlaces (arcos). Por otro lado hace buen uso de la memoria. Se utiliza bastante cuando el nmero de enlaces es mucho menor que O(n2). Desventaja de las listas de adyacencia La representacin con listas de adyacencia es que pueden llevar un tiempo O(n) determinar si existe un arco del vrtice i al vrtice j, ya que pueden haber O(n) vrtices en la lista de adyacencia. Para el vrtice i. Leccin 15: Exploracin de grafos A la hora de explorar un grafo, nos encontramos con dos mtodos distintos. Ambos conducen al mismo destino (la exploracin de todos los vrtices o hasta que se encuentra uno determinado), si bien el orden en que stos son "visitados" decide radicalmente el tiempo de ejecucin de un algoritmo, como se ver posteriormente. En primer lugar, una forma sencilla de recorrer los vrtices es mediante una funcin recursiva, lo que se denomina bsqueda en profundidad. La sustitucin de la recursin (cuya base es la estructura de datos pila) mientras que el segundo mtodo de bsqueda o recorrido, la bsqueda en amplitud o anchura lo proporciona una cola.
10
Tomado de: http://www.algoritmia.net/articles.php?id=18
185
Figura 88 Representacin grafica de un grafo
Fuente: http://www.algoritmia.net/articles.php?id=18 Suponiendo que el orden en que estn almacenados los nodos en la estructura de datos correspondiente es A-B-C-D-E-F... (el orden alfabtico), se tiene que el orden que seguira el es destacable que el nodo D es el ltimo en explorarse en la bsqueda en profundidad pese a ser adyacente al nodo de origen, es decir el nodo A. Esto es debido a que primero se explora la rama del nodo C, que tambin conduce al nodo D. En este ejemplo hay que tener en cuenta que es fundamental el orden en que los nodos estn almacenados en las estructuras de datos. Si, por ejemplo, el nodo D estuviera antes que el C, en la bsqueda en profundidad se tomara primero la rama del D (con lo que el ltimo en visitarse sera el C), y en la bsqueda en anchura se explorara antes el H que el G. El recorrido en profundidad sera el siguiente: A-B-E-I-F-C-G-J-K-H-D En un recorrido en anchura el orden sera, por contra: A-B-C-D-E-G-H-I-J-K-F Bsqueda en profundidad Se implementa de forma recursiva, aunque tambin puede realizarse con una pila. Se utiliza un array val para almacenar el orden en que fueron explorados los vrtices. Para ello se incrementa una variable global id (inicializada a 0) cada vez que se visita un nuevo vrtice y se almacena id en la entrada del array val correspondiente al vrtice que se est explorando. La siguiente funcin realiza un mximo de V (el nmero total de vrtices) llamadas a la funcin visitar, que implementamos aqu en sus dos variantes: representacin por matriz de adyacencia y por listas de adyacencia. 186
int id=0; int val[V]; void buscar() { int k; for (k=1; k<=V; k++) val[k]=0; for (k=1; k<=V; k++) if (val[k]==0) visitar(k); } void visitar(int k) // matriz de adyacencia { int t; val[k]=++id; for (t=1; t<=V; t++) if (a[k][t] && val[t]==0) visitar(t); } void visitar(int k) // listas de adyacencia { struct nodo *t; val[k]=++id; for (t=a[k]; t!=z; t=t->sig) if (val[t->v]==0) visitar(t->v); } El resultado es que el array val contendr en su i-sima entrada el orden en el que el vrtice i-simo fue explorado. Es decir, si tenemos un grafo con cuatro nodos y fueron explorados en el orden 3-1-2-4, el array val quedar como sigue: val[1]=2; // el primer nodo fue visto en segundo lugar val[2]=3; // el segundo nodo fue visto en tercer lugar val[3]=1; // etc. val[4]=4; Una modificacin que puede resultar especialmente til es la creacin de un array "inverso" al array val que contenga los datos anteriores "al revs". Esto es, un array en el que la entrada i-sima contiene el vrtice que se explor en isimo lugar. Basta modificar la lnea val[k]=++id; // sustituyndola por val[++id]=k; Para el orden de exploracin de ejemplo anterior los valores seran los siguientes: val[1]=3; val[2]=1;
187
val[3]=2; val[4]=4; Bsqueda en amplitud o anchura La diferencia fundamental respecto a la bsqueda en profundidad es el cambio de estructura de datos: una cola en lugar de una pila. En esta implementacin, la funcin del array val y la variable id es la misma que en el mtodo anterior. struct tcola *cola; void visitar(int k) // listas de adyacencia { struct nodo *t; encolar(&cola,k); while (!vacia(cola)) { desencolar(&cola,&k); val[k]=++id; for (t=a[k]; t!=z; t=t->sig) { if (val[t->v]==0) { encolar(&cola,t->v); val[t->v]=-1; } } } } Fin del programa11 Aunque las estructuras de datos no lineales tambin se pueden implementar por medio de apuntadores, el cdigo que se presenta corresponde a la implementacin por medi de arreglos.
11
Tomado de: http://www.algoritmia.net/articles.php?id=18 consultado en Junio 10 de 2009
188
Actividades de Autoevaluacin de la Unidad 3 Ejercicio 1. Especificar una funcin que calcule la frontera de un rbol general, donde por frontera se entiende la lista formada por los elementos almacenados en las hojas del rbol tomados de izquierda a derecha. Ejercicio 2. Implementar un programa para la especificacin de rboles con las operaciones siguientes: Calcular la talla del rbol, es decir, el nmero de nodos de la rama ms larga. Calcular el nmero de nodos. Calcular el nmero de hojas. calcular el grado del rbol. Ejercicio 3. Implementar un rbol binario de nivel 3 que permita ingresar nmeros en tiempo de ejecicin, por medio de un men de opciones que visualice en cada recorrido (Inorden, preorden y posorden). Ejercicio 4. Implemente el funcionamiento de un rbol binario haciendo uso del modo grafico de C, donde se gestionen los tres recorridos y se muestre la grafica. Ejercicio 5. Desarrollar un programa que reconstruya un rbol binario a partir de las dos listas que son sus rboles izquierdo y derecho respectivamente, se debe ingresar la raz y con estos datos imprimir los tres recorridos en Preorden e Inorden y Postorden. Ejercicio 6. Escribir un programa que ordene una lista de elementos distintos utilizando como estructura auxiliar un rbol binario de bsqueda. Ejercicio 7. Implemente un rbol binario por medio del entorno grfico de C++, de tal manera que se pueda gestionar la teora de un rbol binario (Creacin y visualizacin del rbol, al igual que los tres recorridos Inorden, Preorden, Posorden, altura del rbol, el grado). Ejercicio 8. Implemente un grafo por medio del entorno grfico de C++, de tal manera que se pueda gestionar la teora de grafos (Creacin y visualizacin del grafo, al igual que imprima los dos recorridos en profundidad y en amplitud).
189
Fuentes Documentales de la Unidad 3 AGUILAR, Luis (2003). Fundamentos de programacin, algoritmos, estructura de datos y Objetos, Tercera edicin. Espaa: McGRAW-HILL. AGUILAR, Luis (200). Programacin en C++, Algoritmos, estructura de datos y Objetos. Espaa: McGRAW-HILL. AGUILAR, Luis (2003). Fundamentos de programacin, algoritmos, estructura de datos y Objetos Tercera edicin. Espaa: McGRAW-HILL. AGUILAR Luis, ZAHONERO Martnez (2004). Algoritmos y Estructuras de Datos. Una perspectiva en C. Madrid-Espaa: McGraw-Hill. ARCEO B, Frida y Otro (1999). Estrategias Decentes Para un Aprendizaje Significativo. Mexico D,F: McGRAW-HILL. BROOKSHEAR, J. Glenn (1995). Introduccin a las ciencias de la Computacin (Cuarta Edicn). Edicin Espaola: Addison-Wesley Iberoamericana. DEYTEL Y DEYTEL(1999). Como programa C++. Segunda Edicin. Mexico D.F: Prentice Hall. McGRAW-HILL. FARREL, Joyce (2000). Introduccin a la programacin lgica y diseo. Mexico D.F: Thomson. KENNETH C, Louden (2004). Lenguajes de programacin. Segunda edicin. MexicoD.F: Thomson. Salvador, Pozo (2002). Estructuras Dinmicas de datos- rboles. Consultado en Octubre de 2008 en http://c.conclase.net/edd/index.php?cap=006. ESPINOZA, David (2004). Curso bsico de Algoritmia. Consultado en Octubre, 24 de 2008 en http://www.geocities.com/david_ees/Algoritmia/curso.htm. CACERES, Abdiel (2005). Estructuras de datos en C++. Consultado en Febrero 25 de 2009 en http://computacion.cs.cinvestav.mx/~acaceres/courses/estDatosCPP/ ALGORITMIA.NET (2003). Grafos. Consultado en Noviembre de 2008 en http://www.algoritmia.net/articles.php?id=18. 190
CASTILLO, Lenin (2008). rboles binarios de bsqueda (ABB). Consultado en Mayo 2 de 2009 en http://ldcastillo.wordpress.com/tema-5-arboles-binarios-debusqueda-abb/. PARDO, Pilar (2008). Teora de Grafos.Consultado en Julio 10 de 2009 en http://www.slideshare.net/pilypardo/grafos-1407276.
191

Estructura de Datos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Estructura de Datos

Enviado por

Direitos autorais:

Formatos disponíveis

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD ESCUELA DE CIENCIAS BSICAS TECNOLOGA E INGENIERA CONTENIDO DIDCTICO DEL CURSO: 301305

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA

301305 ESTRUCTURA DE DATOS HERMES MOSQUERA ANGULO (Director Nacional)

CARLOS ROBERTO ROJAS Acreditador

POPAYAN Enero de 2011

Tabla 1.30 Tabla 2.31

ASPECTOS DE PROPIEDAD INTELECTUAL Y VERSIONAMIENTO

Leccin 13 Leccin 14 Leccin 15

Figura 3 Salida en pantalla de progra3.cpp

Figura 4 Salida en pantalla de progra4.cpp

Figura 5 Salida en pantalla de progra5.cpp

Figura 6 Salida en pantalla de progra6.cpp

Figura 9 Salida en pantalla de progra9.cpp

/* se asigna la direccin que contiene q a p */ /* imprime la direccin almacenad en p. */

Figura 11 Salida en pantalla de progra11.cpp

CAPITULO 3: OPERADORES Y FUNCIONES EN LA GESTIN DE MEMORIA

Tomado de: http://www.pablin.com.ar/computer/cursos/c1/allocate.html

El resultado en pantalla de Progra17.cpp se puede visualizar en la Figura 17.

Figura 17 Salida en pantalla de progra17.cpp

Tomado de: http://www.fismat.umich.mx/mn1/manual/node10.html

Tomado de: http://www.conclase.net/c/librerias/funcion.php?fun=calloc

No. de Lneas de cdigo

// 1 // 2 // 3 // 4 // 5 // 6 // 7 //8 //9 //10

Figura 20 Representacin grfica de una pila de monedas

Figura 23 Men de opciones de la pila

Figura 24 Definicin de la funcin insertar()

Figura 25 La funcin insertar() en el case 1

Figura 26 Instrucciones de la funcin insertar()

Figura 27 Vista de la definicin de las funciones insertar, visualizar y extraer

else { clrscr(); inicio=c; while (inicio!=NULL) { cout<<"Numero: "<<inicio->numero<<endl; inicio=inicio->sig; }

Figura 28 Salida en pantalla de Progra21.cpp

//FUNCION PARA INSERTAR DATOS A LA PILA 76

} }while(d != 4); // mientras que la opcion no sea 4 return 0;

{ while(tope != NULL) Pop(); printf("PILA VACIA"); getch(); break; }

Figura 31 Representacin grfica de una cola de personas.

Tomado de: http://www.uhu.es/17207-18209/Transparencias/Tema3.pdf

Figura 32 Representacin grfica de una cola

void main() { char opcion; do{ 86

cout<<"NO HAY ELEMENTOS EN LA COLA"; getch();

Figura 34 Salida en pantalla de Progra25.cpp

Esta es una definicin

Figura 37 Representacin grfica de listas enlazadas

clrscr(); struct lista *entero; int dato; crear(&entero); 101

anterior = puntero; puntero = puntero->sig;

anterior->sig = puntero->sig; delete puntero; } }

Figura 38 Salida en pantalla de Progra27.cpp

Figura 40 Salida en pantalla de progra29.cpp

Figura 41 Representacin grfica de una lista doblemente enlazada

Tomado de: http://ldcastillo.wordpress.com/tema-2-listas-doblemente-enlazadas/

//selecionar una operacion int menu(void) {

Figura 42 Salida en pantalla de progra30.cpp

Figura 43 Representacin grfica de una Lista Circular

Figura 44 Lista circular simplemente enlazada

Figura 45 Lista circular doblemente enlazada

Figura 46 Primer nodo de la lista circular

Figura 48 Nuevo nodo insertado en la lista circular

//Fin del programa6

Tomado de: http://www.conclase.net/c/edd/index.php?cap=004c

El resultado en pantalla se puede visualizar en la figura 49.

Figura 49 Salida en pantalla de progra31.cpp

Figura 50 Representacin grfica de rboles

Tomado de: http://www.conclase.net/c/edd/index.php?cap=006b.

Figura 55 Inclusin de la ruta C:\TC\BGI

/* se asigna la direccin que contiene q a p / / imprime la direccin almacenad en p. */