301305

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD
ESCUELA DE CIENCIAS BSICAS TECNOLOGA E INGENIERA

CONTENIDO DIDCTICO DEL CURSO: 301305 ESTRUCTURA DE DATOS
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA

PROGRAMA INGENIERA DE SISTEMAS
301305 ESTRUCTURA DE DATOS

HERMES MOSQUERA ANGULO
(Director Nacional)
POPAYAN
Enero de 2012

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 10 Salida en pantalla de progra10.cpp ....................................................... 30
Figura 13Salida en pantalla de progra13.cpp ........................................................ 37
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 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 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 41 Representacin grfica de una lista doblemente enlazada ................. 109
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 50 Representacin grfica de rboles ...................................................... 132
Figura 51 Interfaz grfica del compilador Borland C++ 5.5. ................................ 138
Figura 52 Activacin de las libreras Grficas138
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 fueron desarrollados en compilador Turbo C++ 3.0, pero pueden ser
adaptados para cualquier compilador de C++ de su preferencia, teniendo en
cuenta las caractersticas de cada compilador.
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
Introduccin
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.
Justificacin
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

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.
Intencionalidades
Formativas
Profundizar en aspectos bsicos en apuntadores y la

asignacin dinmica de memoria.
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.
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
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
Funciones Malloc() y Free()
13

Leccin 14
Leccin 15
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
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
15

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.
Operadores para trabajar apuntadores
16

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 <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 <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

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 <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 <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 <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 <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.
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 <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.
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 <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 <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

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.
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
BYTES REQUERIDOS
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)
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:
Tabla 2: Otros tipos de datos comunes
TIPO DATO
ESPACIO
MEMORIA
RANGO PERMITIDO
32

unsigned char
Char
short int
unsigned int
Int
unsigned long
Enum
Long
Float
Doubl
long doubl
Void
8 bits
8 bits
16 bits
32 bits
32 bits
32 bits
16 bits
32 bits
32 bits
64 bits
80 bits
sin valor
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 <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 <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();
}
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.
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 <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();
}
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 <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();
}
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.
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;
}
El resultado de la ejecucin del listado llamado Progra16.cpp se visualiza en la
Figura 15.
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
//1
#include <conio.h>
//2
void main()
//3
{
//4
clrscr();
//5
int *numero;
//6
numero = new int ;
//7
*numero = 10 ;
//8
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.
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 <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 <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.
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.
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 ;
No. de Lneas de cdigo

// 1
// 2
// 3
// 4
// 5
Enunciado 2
Int punt;
punt = punt + 1;
punt = punt 2;
punt++;
punt--;
// 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.
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.
Introduccin
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++.
Justificacin
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.
Intencionalidades Conocer y aplicar el funcionamiento de las estructuras de

Formativas
datos lineales.
57

Determinar las tcnicas y estructuras utilizadas, desde las

perspectivas de las aplicaciones de software, para resolver
problemas mediante la utilizacin de las estructuras lineales
pilas, colas y listas.
Profundizar en la fundamentacin terica y prctica de las
estructuras dinmicas lineales Pilas, Colas y Listas.
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
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
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 se utiliz 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 <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>
void extraer(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.
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(tope != NULL)
Pop();
printf("PILA VACIA");
getch();
break;
}
}
}while(d != 4); // mientras que la opcion no sea 4
return 0;
}
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.
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 <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

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');
}
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
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.
{
if (CABEZA==NULL)
89

{
cout<<"NO HAY ELEMENTOS EN LA COLA";
getch();
}
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 <conio.h>
#include <stdlib.h>
void extraer(void);
struct cola
{
char nombre[20];
struct cola *sig;
}*CABEZA=NULL,*AUXILIAR=NULL,*FINAL=NULL;
main()
{
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);
}
}
{
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
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>
#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.
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
se encuentran ordenados y pueden variar en nmero. Esta es una definicin
general, que incluye los ficheros y vectores.
97

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 <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

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;
}
// 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);
}
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))
{
anterior = puntero;
}
if(puntero->dato != dato)
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<< " ";
}
}
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 <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.
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 <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>
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 = 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;
}
}
ant->sig = i; //ponerlo en el final
i->sig = NULL;
i->ant = ant;
*final = i;
}
//eliminar un elemento de la lista
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

{
info->ant->sig = info->sig;
if(info != *final)
info->sig->ant = info->ant;
else
*final = info->ant;
}
free(info); //devolver la memoria al sistema
}
clrscr();
}
//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);
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

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


BROOKSHEAR, J. Glenn (1995). Introduccin a las ciencias de la Computacin.
Cuarta Edicn. Edicin Espaola: Addison-Wesley Iberoamericana.
D.F: Thomson.
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.
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.
Introduccin
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.
Justificacin
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
129

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.
Intencionalidades
Formativas
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

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.
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
131

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;
};
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
/
3
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
/
/
2
Quinto nmero: 4 (4 es menor que 5 pero es mayor que 3) entonces va al lado

derecho del 3. Nada complicado.
5
/
3
/ \
2
7
4
Sexto nmero: 8 (8 es mayor que 5 y mayor que 7) en este caso se ingresa al lado
derecho de 7.
155

5
/
3
/
7
\
\
4
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
/
3
/
2
7
\
\
4
8
\
9
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
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
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
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>
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

preorden( raiz );
getch();
break;
case '2':
inorden( raiz );
getch();
break;
case '3':
posorden( raiz );
getch();
break;
}
}
return;
}
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':
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':
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 ) )
{
getch();
break;
}
menu_busquedas();
break;
case 'A':
if( vacio( raiz ) )
{
getch();
break;
}
case 'N':
if( vacio( raiz ) )
{
getch();
break;
}
menu_nodos();
break;
case 'P':
if( vacio( raiz ) )
{
166

getch();
break;
}
menu_podar();
break;
}
}
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
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 <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;
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;
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;
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;
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

}
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;
}
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.
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
176

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
la red de carreteras de un pas, puesto que una misma carretera puede ser
recorrida en ambos sentidos.
177

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
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
178

etiquetados. Para ampliar este concepto se puede visualizar la figura 83. Que se
Figura 83 Representacin grfica de grafos etiquetados
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.
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}
179

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
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.
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(n2).
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
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(n 2).
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


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


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.
D.F: Thomson.
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.
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

301305

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

301305

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

ESCUELA DE CIENCIAS BSICAS TECNOLOGA E INGENIERA

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA

301305 ESTRUCTURA DE DATOS

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

UNIDAD 1. MEMORIA DINMICA....13

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

UNIDAD 2. ESTRUCTURAS DE DATOS LINEALES....56

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Leccin 4: Estructura para la creacin de un rbol de orden tres .................... 134

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

LISTADO DE GRFICOS Y FIGURAS

Figura 1 Salida en pantallade progra1.cpp ............................................................ 17

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Figura 23 Men de opciones de la pila .................................................................. 66

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Figura 47 Insercin del segundo nodo ................................................................ 120

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Figura 71 Resultado del recorrido en preorden del rbol .................................... 150

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

ASPECTOS DE PROPIEDAD INTELECTUAL Y VERSIONAMIENTO

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

El curso de estructura de datos cobra vital importancia en la aplicacin de la

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

La memoria de la computadora es un recurso invaluable y

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

cualquier otra situacin, la informacin (nombres, precios

Profundizar en aspectos bsicos en apuntadores y la

Realizar aplicaciones en lenguaje C++ utilizando

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Aplicacin a la asignacin de memoria con Malloc() y

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

x es un apuntador de tipo entero.

Operadores para trabajar apuntadores

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Los operadores utilizados para trabajar variables apuntadores son el ( * ) asterisco

* toma su operando como una direccin de memoria y retorna la

Aplicacin prctica del uso de apuntadores

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Leccin 2: Variables Automticas y Apuntadores

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

En la lnea 7, Se asigna el valor 100 a la variable automatica.

El resultado de Progra2.cpp se puede observar en la figura 2, que se muestra a

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Al declarar un apuntador, se est especificando el tipo de variable al que va a

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Figura 3 Salida en pantalla de progra3.cpp

Leccin 3: Apuntadores y Cadenas

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

En la figura 4, se visualiza la salida en pantalla de progra4.cpp, se presentan dos

Figura 4 Salida en pantalla de progra4.cpp

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Figura 5 Salida en pantalla de progra5.cpp

Leccin 4: Paso de Arreglos Como Parmetros

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

de arreglos se hace por referencia, ya que el nombre del arreglo corresponde a un

El resultado de la salida en pantalla de progra6.cpp se visualiza en la figura 6, que

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

Figura 6 Salida en pantalla de progra6.cpp

Implementacin de la funcin valor() por medio de apuntadores

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA UNAD

despliega el resultado, tal como se puede evidenciar en la figura 7, que se muestra