Estructuras de Datos Jerarquicas PDF

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS
ESTRUCTURAS DE DATOS JERRQUICAS
ESTRUCTURA DE DATOS JERRQUICAS
TEORA GENERAL DE ARBOLES
Hermes Mosquera
Julio de 2013

Contenido
ESTRUCTURA DE DATOS JERRQUICAS ......................................................... 3

1. RBOLES ........................................................................................................ 3
1.1 Teora general de rboles .......................................................................... 3
1.2 Definicin de rboles .................................................................................. 4
1.3 Otros conceptos de la teora general de rboles ....................................... 5
1.4 rbol completo ............................................................................................ 5
1.5 Estructura para la creacin de un rbol de orden dos ................................ 6
1.6 Operaciones bsicas con rboles ............................................................... 7
1.7 rboles ordenados ...................................................................................... 8
2.1 RBOLES BINARIOS ...................................................................................... 9
2.1 Conceptualizacin de Arboles Binarios....................................................... 9
2.2 Representacin grfica de un rbol binario .............................................. 10
2.3 Clasificacin de los rboles binarios ......................................................... 14
2.3.1 rbol Binario completo: .......................................................................... 14
2.3.3 rbol Binario Isomorfo: .......................................................................... 16
2.4 Formas de Recorrer un rbol Binario ....................................................... 16
2.4.1 Recorrido en Preorden .......................................................................... 17
2.4.2 Recorrido en Inorden ............................................................................ 18
2.4.3 Recorrido en Postorden ......................................................................... 19
2.5 bol binario de bsqueda (ABB) ............................................................... 21
2.5.1 Ventajas de los rboles binarios de bsqueda ...................................... 23

2.5.2 Operaciones en ABB ............................................................................. 24
2.5.3 Borrar un nodo rama con intercambio de un nodo hoja ......................... 24
2.5.4 Borrar un nodo rama con intercambio de un nodo rama ........................ 24
2.6 Implementacin de un rbol binario con Punteros .................................... 26
2.7 Implementacin de los rboles binarios en modo grfico ......................... 34
2.7.1 Actividad de verificacin ........................................................................ 42
2.8 Introduccin al Modo Grfico de C++ ....................................................... 43
2.8.1 Configuracin del modo grafico de C++ en Borland C++5.5.................. 43
2.9 Otras opciones de compilador para implementar Modo grafico. ............... 46
2.9.1 El compilador DevC++: .......................................................................... 46
Fuentes Bibliogrficas..................................................................................... 51

ESTRUCTURA DE DATOS JERRQUICAS
1. RBOLES
Introduccin
Los rboles a diferencia de las listas son una estructura de datos de no lineal,
atendiendo 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 la teora general de los arboles binarios,
bsqueda, sus formas de recorridos.
y rboles binarios de
Finalizando con un apartado ampliamente desarrollado a cerca del modo grfico

de C++, finalizando con un programa de aplicacin del modo grfico que muestra
figuras geomtricas y texto manejando colores y rellenos.
1.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.
1.2 Definicin de rboles

Los rboles son estructuras de datos muy similares a las listas doblemente
enlazadas, en el sentido que tienen punteros que apuntan a otros elementos, pero
no tienen una estructura lgica de tipo lineal o secuencial como aquellas, sino
ramificada. Tienen aspecto de rbol, de ah su nombre.
Su estudio desde el punto de vista matemtico pertenece a la teora de grafos;
desde el punto de vista informtico son estructuras de datos, lo que significa que
cada elemento, denominado nodo u hoja, contiene un valor. Su estudio
corresponde a la teora de bases de datos, y en esta terminologa, los nodos que
dependen de otros se denominan hijos. Cada hoja puede tener un mximo de
hijos, si no tiene ninguno se dice que es un nodo terminal.
Un rbol es una estructura de datos no lineal en la que cada nodo puede
apuntar a uno o varios nodos. Tambin se suele dar una definicin recursiva: un
rbol es una estructura compuesta por un dato y varios rboles. Esto son
definiciones simples. Una representacin grfica de los rboles se puede
visualizar en la figura 50 presente a continuacin.
Figura 1. Representacin grfica de rboles
Fuente: http://www.conclase.net/c/edd/index.php?cap=006b

1.3 Otros conceptos de la teora general de rboles
Con relacin al tipo de nodos que hacen parte de los rboles, se identifican
algunos nodos:
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'.
1.4 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
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.
1.5 Estructura para la creacin de un rbol de orden dos

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 dos:
struct Arbol {
int dato;
struct Arbol *rama1;
struct Arbol *rama2;
};

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];
};
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.
1.6 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.

1.7 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.
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
claves1.
http://www.conclase.net/c/edd/index.php?cap=006b.

2.1 RBOLES BINARIOS

Introduccin
Los rboles binarios son estructuras de datos de tipo jerrquico. En el presente
apartado 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.
2.1 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 1Estructura 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.

2.2 Representacin grfica de un rbol binario
Figura 3. 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 4. Y el otro de raz I tal como se
muestra en la figura 5.
Figura 4. 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 3.
10

Figura 5. 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 6.
Figura 2. 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.
Hoja: Una hoja es un nodo que no tiene ramificaciones. Por ejemplo
Figura 7. Representacin grfica de un nodo hoja
11

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

Longitud: Longitud es el nmero de nodos que se deben recorrer para pasar de
un nodo a otro. Por ejemplo:
Figura 9. 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 caminoA -----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.
13

Figura 10. 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.
2.3 Clasificacin de los rboles binarios

2.3.1 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 11. Representacin grfica de un rbol binario completo.
14

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 12. 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.
2.3.2 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:
15

Figura 13. Representacin grfica de rboles semejantes
Estos rboles son semejantes. Contienen los mismos valores en cada uno de sus
nodos.
2.3.3 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 14. 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.
2.4 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
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.
16

2.4.1 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 15. 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 15. 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 16.
Figura 16. Resultado del recorrido en preorden del rbol
Una forma de implementar los recorridos de un rbol binario es a travs de

funciones especficas para dicha tarea.
17

void preorden(tarbol *a)

{
if (a != NULL) {
visitar(a);
preorden(a->izq);
preorden(a->der);
}
}
2.4.2 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 17, 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 17 es:3 5 - 7 - 10 - 11 - 12 15 Tal como se muestra en la figura.
18

Figura 17. 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.
2.4.3 Recorrido en Postorden
Recorrer un rbol en Postorden consiste en primer lugar en recorrer el subrbol
izquierdo en Postorden, luego serecorre 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 17:
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.
19

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 nmero10.
El resultado completo del recorrido en Postorden para el rbol de la figura 17 es:
3 - 7 - 5 - 11 - 15 12 - 10 Tal como se muestra en la siguiente figura 18.
Figura 18. 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 19, con datos de tipo carcter con el propsito de
identificar los recorridos es Preorden, Inorden, Postorden.
20

Figura 19. 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
2.5 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.
21

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

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

2.5.2 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.
2.5.3 Borrar un nodo rama con intercambio de un nodo hoja

En el rbol de ejemplo, representado en la figura 20, 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 20. Borrado de un nodo rama con intercambio de nodo hoja
Fuente: http://www.conclase.net/c/edd/index.php?cap=007
2.5.4 Borrar un nodo rama con intercambio de un nodo rama

Para este ejemplo se tiene otro rbol. En ste se borrar el elemento 6.
24

Figura 21. 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 22. 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.
8. Se hace que el puntero de 'Padre' que apuntaba a 'nodo', ahora apunte a
NULL.
25

9. Se procede a borrar el 'nodo'.
Figura 23. Intercambio de un nodo rama con intercambio de nodo rama
Este modo de actuar asegura que el rbol sigue siendo ABB

Para aplicar un poco la teora de rboles binarios, es importante implementar un
programa que haciendo uso de apuntadores permita ingresar datos al rbol,
consultar datos, visualizar los datos, eliminar datos del rbol y mostrar sus tres
recorridos. Para este ejemplo no se hace uso de la aplicacin del modo grafico.
2.6 Implementacin de un rbol binario con Punteros
Programa1.cpp
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <iostream.h>
struct arbol
{
int dato;
struct arbol *izq;
struct arbol *der;
}*raiz;
enum{ FALSO=0, VERDADERO };
/*PROTOTIPOS*/
26

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;
else raiz->der= hoja;
27

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;
if( vacio( hoja ) )
{
28

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;
}
/*Recorridos*/
void preorden( struct arbol *hoja )
{
29

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':
preorden( raiz );
getch();
break;
case '2':
30

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." ;
cout << "\n3. Salir." ;
_op= getch();
switch( _op )
{
case '1':
31

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 ) )
{
cout << "\n\nEste numero ya ha sido insertado." ;
getch();
break;
}
raiz= insertar( raiz, raiz, val );
32

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

cout << "\n\nPulsa para salir..." ;
getchar();
return 0;
}
El resultado despus de la compilacin y ejecucin del listado, se puede
visualizar en la figura 24 que se muestra a continuacin.
Figura 24. Salida en pantalla del programa1
Despus de haber profundizado en la temtica de relacionada con la teora de

rboles, rboles binarios solo resta presentar un programa completo funcional
donde se da aplicabilidad a la teora de rboles haciendo buen uso del modo
grfico de C++, lo que permite acercarnos a la programacin orientada a Objetos
con la Interfaz grafica de usuario.
2.7 Implementacin de los rboles binarios en modo grfico
El siguiente programa llamado programa2, muestra la aplicabilidad del modo
grafico de C++ al servicio de la teora general de rboles binarios.
Programa2.cpp
//Autor: Carlos Javier Guzmn
#include <graphics.h>
#include <iostream.h>
#include <string.h>
#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);
34

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);
cin>>x;
texto();// llama caja de texto para no sobrescribir
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
35

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
outtextxy(220,200,"G"); //G
}
outtextxy(55,388,"Cuandos hijos tiene D ");
gotoxy(31,25);
cin>>x;
D=verificar(x);
if(D==1)//D
{
36

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);
}
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
37

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
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)
{
38

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
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");
39

}
}
} //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);
}
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);
40

}
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()
{
}
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;
41

}
if(n==1 || n==2)
{
return n;
}
return n;
}
2.7.1 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 programa2, 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.
Para finalizar la temtica propuesta en el presente apartado, se presenta a

continuacin 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 rboles binarios de bsqueda.
42

2.8 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 modogrfico de C++, teniendo en cuenta que en esta
unidad se har la representacin grfica de los rboles.
2.8.1 Configuracin del modo grafico de C++ en Borland C++5.5
La configuracin del modo grafico para C++ depende del compilador, cada uno
tiene sus propias caractersticas, por ejemplo para este caso he utilizado el
compilador Borland C++ 5.5, 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 disponible en la caja de herramientas del
curso
ubicada
en
el
entorno
de
conocimiento.
https://www.dropbox.com/home/Public/Compiladores%20para%20C%2B%2B
A continuacin se muestra la interfaz grfica del compilador Borland C++ 5.5,

pues no requiere de ningn tipo de configuracin adicional ya cuenta con las
libreras grficas.
Figura 25. Interfaz grfica del compilador Borland C++ 5.5.
43

Solo basta con compilar el programa para que se genere el archivo ejecutable con
extensin .exe que es el archivo a ejecutar para visualizar en modo grfico 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:
Promama 3.cpp
#include <graphics.h>
#include <conio.h>
#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;
}
Progra4.cpp
#include <graphics.h> // Encabezado con declaraciones de grficos
44

#include <conio.h>
#include <stdio.h>
void main(void)
{
int monitor=DETECT, modo; // Declaracion de tipo de monitor y modo
initgraph(&monitor,&modo,"");
// Inicializa el modo grafico indicando el monitor y modo utilizado
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
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 programa4.cpp lo visualiza en la siguiente figura 26.
45

Figura 26. Salida en pantalla de programa4 Modo grafico de C++.
2.9 Otras opciones de compilador para implementar Modo grafico.
2.9.1 El compilador DevC++:

Dev C++ es uno de los ms utilizados para el lenguaje C++ y como tal tambin
puede ser configurado con sus libreras graficas para trabajar grficos, veamos
cmo hacerlo.
Para poder hacer programas con entorno grfico en DEV C++ se requiere hacer
uso de unas libreras grficas que no vienen por defecto con l.
Los pasos para importar dichas libreras en Dev C++ son los siguientes:
1. Descargue las libreras, sin abrirlas, slo descrguelas y cpielas en el
directorio INCLUDE y LIB de su Dev C++ (dnde est instalado). De la siguiente
manera:
Librera
Ruta para descargar
graphics.h
libbgi.a
http://www.cs.colorado.edu/~main/bgi/dev-c++/graphics.h
http://www.cs.colorado.edu/~main/bgi/dev-c++/libbgi.a
Ruta para copiar en su

equipo
C:\Dev-Cpp\include
C:\Dev-Cpp\lib
Nota: La ruta para copiar la descarga es la ruta por defecto donde se instala Dev
C++. Si en el momento de la instalacin usted cambi esa ruta, deber copiar las
libreras en la ruta que usted indic, dentro de los directorios INCLUDE y LIB
respectivamente.
46

2. Abra Dev C++ y cree un proyecto nuevo.
Figura 27. Interfaz Nuevo proyecto
3. Seleccione el tipo: Console Aplication y dele el nombre que usted desee.

Figura 28. Opciones del proyecto
47

4. Seleccione el men PROYECTO y dentro de l, OPCIONES DE PROYECTO
Figura 29. Proyecto nuevo
Figura 30. Seleccin de la consola
48

5. Seleccione la pestaa : ARGUMENTOS
Figura 31. Pestaa Argumentos
6. En la columna de la derecha: ENLAZADOR (LINKER) copie tal cual las

siguientes lneas (incluyendo los guiones).
-lbgi
-lgdi32
-lcomdlg32
-luuid
-loleaut32
-lole32
Figura 32. Enlazador Linker
49

De clic en aceptar y en este momento ya tiene descargadas e importadas las
libreras en el proyecto actual.
Puede probarlas copiando el siguiente cdigo y compilndolo:
#include<graphics.h>
int main( )
{
initwindow( 700 , 700 , "Mi primera grafica");
circle(200, 200, 100);
circle(300, 200, 100);
circle(250, 300, 100);
getch();
return 0;
}
Figura 33. Pantalla de edicin del cdigo
El resultado de la salida en pantalla deber ser:

Figura 34. Salida en pantalla de grficos
50

Fuentes Bibliogrficas
C++ con Clase. Estructuras de datos. Capitulo 6. rboles. Recuperado de.

http://www.conclase.net/c/edd/index.php?cap=006#inicio
C++ con Clase. Estructuras de datos. Capitulo 7. rboles binarios de bsqueda.
Recuperado de. http://www.conclase.net/c/edd/index.php?cap=007#inicio
51

Estructuras de Datos Jerarquicas PDF

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Estructuras de Datos Jerarquicas PDF

Caricato da

Copyright:

Formati disponibili

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

ESTRUCTURAS DE DATOS JERRQUICAS

ESTRUCTURA DE DATOS JERRQUICAS

TEORA GENERAL DE ARBOLES

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

ESTRUCTURA DE DATOS JERRQUICAS ......................................................... 3

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

ESTRUCTURA DE DATOS JERRQUICAS

Finalizando con un apartado ampliamente desarrollado a cerca del modo grfico

1.1 Teora general de rboles

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

1.2 Definicin de rboles

Figura 1. Representacin grfica de rboles

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

1.4 rbol completo

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

1.5 Estructura para la creacin de un rbol de orden dos

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

1.6 Operaciones bsicas con rboles

Aadir o insertar elementos a un rbol.

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

rboles binarios de bsqueda (ABB): son rboles de orden 2 que

rboles AVL: son rboles binarios de bsqueda balanceados: es decir,

rboles perfectamente equilibrados: son rboles binarios de bsqueda en

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

2.1 RBOLES BINARIOS

2.1 Conceptualizacin de Arboles Binarios

Figura 1Estructura de un rbol binario

La rama izquierda y la derecha, tambin son dos rboles binarios. El Vrtice

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

Figura 4. Representacin grfica del subrbol izquierdo

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

Nodo: Un rbol binario es un conjunto de elementos cada uno de los cuales se

En los tres casos el nodo A es un padre. En el caso 1 es un padre que no tiene

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

Al nodo C se puede llegar desde el nodo B. Nunca se puede examinar el nodo B

Del mismo nodo, para llegar al nodo G debemos recorrer el camino:

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

De acuerdo a la figura 64. La longitud entre A y E es 3. La longitud entre G y G es

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

El nodo A, tienen un nivel 0 en tanto que los nodos R y F tienen un nivel 1

2.3 Clasificacin de los rboles binarios

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

Figura 12. Representacin grfica de rbol binario igual

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

Figura 14. Representacin grfica de rboles isomorfos

Peso: El peso de un rbol en un nodo dado es el nmero de nodos en el rbol sin

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

2.4.1 Recorrido en Preorden

Una forma de implementar los recorridos de un rbol binario es a travs de

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

void preorden(tarbol *a)

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

Se puede implementar el recorrido en Inorden de un rbol binario es a travs de

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

Figura 18. Recorrido en Postorden del rbol binario.

Se puede implementar el recorrido en Postorden de un rbol binario es a travs de

TEORA GENERAL DE RBOLES COMO FUNDAMENTOS A LAS

El resultado que arroja al realizar los tres recorridos es el siguiente:

2.5 bol binario de bsqueda (ABB)

la rama de la izquierda contendr elementos menores.

Tal como se ha mantenido la metodologa a lo largo del curso, un ejemplo sera la