Guia Estructura Datos 2

INSTITUTO SUPERIOR TECNOLÓGICO

EUROAMERICANO

GUÍA DIDÁCTICA DE LA MATERIA DE

ESTRUCTURA DE DATOS II

DE LA CARRERA DE:

INFORMÁTICA NETWORKING

RECOPILADO POR:

DOCENTE: ING. DANNY AVILEZ C.

12 MAYO 2014

ContenidoINTRODUCCIÓN..........................................................................................................................................................................1

ESTRUCTURA DE DATOS FUNDAMENTALES ...................................................................................................................2

CLASIFICACIÓN DE ESTRUCTURAS DE DATOS ...............................................................................................................2

ESTRUCTURAS LÓGICAS DE DATOS...............................................................................................................................2

ESTRUCTURAS PRIMITIVAS Y SIMPLES (TIPOS DE DATOS PRIMITIVOS) ..........................................................3

TIPOS DE DATOS PRIMITIVAS...........................................................................................................................................3

*ENTEROS ...........................................................................................................................................................................3

*BOOLEANO .......................................................................................................................................................................3

*CARACTERES........................................................................................................................................................................4

*CADENA.............................................................................................................................................................................4

ESTRUCTURAS DE ARREGLO............................................................................................................................................5

ARREGLOS UNIDIMENSIONALES.....................................................................................................................................6

ARREGLOS MULTIDIMENSIONALES...............................................................................................................................6

ESTRUCTURAS DE REGISTRO ...........................................................................................................................................7

FORMACION DE REGISTROS..............................................................................................................................................7

LLAVES DE IDENTIFICACIÓN............................................................................................................................................8

ARCHIVOS................................................................................................................................................................................8

ARREGLOS...............................................................................................................................................................................9

PUNTEROS Y VARIABLES DE REFERENCIA................................................................................................................10

LISTAS ENLAZADAS...........................................................................................................................................................11

ÁRBOLES................................................................................................................................................................................16

ÁRBOLES BINARIOS ...........................................................................................................................................................18

PROPIEDADES DE LOS ÁRBOLES BINARIOS ..............................................................................................................20

RECORRIDOS DE ÁRBOLES BINARIOS .........................................................................................................................22

2014

1 Guía didáctica de la Materia de Estructura de Datos IIDocente: Ing. Danny Avilez Castillo

INTRODUCCIÓN

Como ya sabemos, las computadoras fueron diseñadas o ideadas como una herramienta mediante la

cual podemos realizar operaciones de cálculo complicadas en un lapso de mínimo tiempo. Pero la

mayoría de las aplicaciones de este fantástico invento del hombre, son las de almacenamiento y acceso

de grandes cantidades de información.

La información que se procesa en la computadora es un conjunto de datos, que pueden ser simples o

estructurados. Los datos simples son aquellos que ocupan sólo una localidad de memoria, mientras que

los estructurados son un conjunto de casillas de memoria a las cuales hacemos referencia mediante un

identificador único.

Debido a que por lo general tenemos que tratar con conjuntos de datos y no con datos simples

(enteros, reales, booleanos, etc.) que por sí solos no nos dicen nada, ni nos sirven de mucho, es

necesario tratar con estructuras de datos adecuadas a cada necesidad.

Las estructuras de datos son una colección de datos cuya organización se caracteriza por las funciones

de acceso que se usan para almacenar y acceder a elementos individuales de datos.

Una estructura de datos se caracteriza por lo siguiente:

• Pueden descomponerse en los elementos que la forman.

• La manera en que se colocan los elementos dentro de la estructura afectará la forma en que

se realicen los accesos a cada elemento.

• La colocación de los elementos y la manera en que se accede a ellos puede ser encapsulada.

2014


ESTRUCTURA DE DATOS FUNDAMENTALES

Tipo de datos Concepto propio de la informática, más específicamente de los lenguajes de

programación, aunque también se encuentra relacionado con nociones similares de las matemáticas y

la lógica.

Estructura de datos Es una clase de datos que se puede caracterizar por su organización y

operaciones definidas sobre ella. Algunas veces a estas estructuras se les llama tipos de datos.

Estructura de datos es una forma de organizar un conjunto de datos elementales (un dato elemental

es la mínima información que se tiene en el sistema) con el objetivo de facilitar la manipulación de

estos datos como un todo o individualmente.

Una estructura de datos define la organización e inter relacionamiento de estos, y un conjunto de

operaciones que se pueden realizar sobre él. Las operaciones básicas son:

• adicionar un nuevo valor a la estructura.

• borrar un valor de la estructura.

• Búsqueda, encontrar un determinado valor en la estructura para realizar una operación con

este valor, en forma SECUENCIAL o BINARIO (siempre y cuando los datos estén

ordenados).

CLASIFICACIÓN DE ESTRUCTURAS DE DATOS

ESTRUCTURAS LÓGICAS DE DATOS

Las estructuras de datos son muy importantes en sistemas computacionales. En un programa, cada

variable pertenece a alguna estructura de datos explícita o implícitamente definida, la cual determina el

conjunto de operaciones válidas para ella. Cada estructura de datos lógica puede tener varias

representaciones físicas diferentes para sus almacenamientos posibles.

2014


ESTRUCTURAS PRIMITIVAS Y SIMPLES (TIPOS DE DATOS PRIMITIVOS)

Las estructura de datos primitivas, son las que no están compuestas por otras estructuras de datos.

Ejemplo: los tipos de datos: enteros, booleanos y caracteres.

Otras estructuras de datos se pueden construir de una o más primitivas cómo son las estructuras de

datos simples que se construyen a partir de estructuras primitvas y son: cadenas, arreglos y registros. A

estas estructuras de datos la respaldan muchos lenguajes de programación.

Tipos de datos simples: Es uno de los conceptos fundamentales de cualquier lenguaje de

programación. Estos definen los métodos de almacenamiento (cadenas, arreglos y registros)

disponibles para representar información, junto con la manera en que dicha información ha de ser

interpretada.

Para crear una variable (de un tipo simple primivito) en memoria debe declararse indicando su tipo de

variable y su identificador que la identificará de forma única.

TIPOS DE DATOS PRIMITIVAS

En todos los lenguajes de programación se manejan datos primitivas. Los tipos de datos primitivas son

los siguientes:

*ENTEROS

Es un miembro del siguiente conjunto de números:

N+1, -n,-2,-1,0,1,2,N+1

Las operaciones fundamentales sobre enteros, son muy conocidas: suma, resta, multiplicación, división,

exponenciación y otras. Todas estas operaciones trabajan sobre un par de números, considerados como

operadores binarios. Un operador unario tiene sólo un operando. La negación, que cambia el signo de un

número, es un ejemplo de un operador unario.

*BOOLEANO

También se le llama lógico. Es un elemento que puede tener uno de dos valores: verdadero o falso. El

conjunto de operaciones definidas sobre este tipo de estructuras de datos es diferente del conjunto de operaciones

2014


para los enteros. Los tres operadores boléanos básicos son not, and y or (negación, conjunción y disyunción,

respectivamente). La siguiente tabla muestra el resultado de aplicar cada uno de estos operadores para cada valor

booleano.

Valor del primeroperando

Valor delsegundooperando

Operadorand or not

Verdadero verdadero V V FVerdadero falso F V FFalso verdadero F V VFalso falso F F V

• AND, el resultado es verdadero si los dos son verdadero. Si uno es falso el resultado es

falso.

• OR, el resultado es verdadero si uno de los dos son verdaderos, si los dos son falsos el

resultado es falso.

• NOT, el resultado es verdadero cuando el primero es falso y el segundo verdadero. Si el

primero es verdadero y el segundo es falso el resultado es falso.

*CARACTERES.

El carácter es una tercera primitiva, es un elemento tomado de un conjunto de símbolos. Ejemplo

{0,1,2,3,4,5,6,7,8,9,A,B,C,D,E….,X,Y,Z,,$%?,..*,+,/,,-}

Se incluyen dígitos, caracteres del alfabeto y caracteres especiales.

*CADENA

Es la que se construye de datos primitvas:

Es una secuencia finita de símbolos tomados de un conjunto de caracteres. El conjunto de caracteres

que se emplea para generar cadenas se llama alfabeto. El conjunto de cadenas que se puede derivar del

alfabeto A={C,D,1} incluye los siguientes: ‘CD1’, ‘CD’, ‘DDC’, ‘1D111’, y así sucesivamente,

incluyendo la cadena nula o vacía. Por lo general, el inicio y final de una cadena lo delimitamos con

comillas.

2014


Las cadenas son un tipo importante de dato y se usan ampliamente. En primera instancia, las cadenas

son el medio básico para escribir programas y transmitirlos a la computadora. Segundo, son el medio

principal de intercambio de información con los usuarios. Tercero, las cadenas se usan para almacenas

información en archivos. Cuarto se usan en lenguajes de programación para nombres de variables,

etiquetas y procedimientos. Y en un contexto más general, son una vía de comunicación entre los seres

humanos.

Definamos de manera más formal a S como cadena:

S:=’a,b,c’

Cada cadena tiene un atributo llamado longitud, el cual es el número de caracteres en la cadena.

ESTRUCTURAS DE ARREGLO

Los arreglos son bloques básicos para la construcción de estructuras de datos más complejas. Casi

todas las estructuras complejas se pueden representar indirectamente mediante arreglos.

Un arreglo es un conjunto finito ordenado de elementos homogéneos, porque todos son del mismo

tipo de dato. Un arreglo puede ser un conjunto de tipo cadena en tanto que otro puede ser de tipo

entero. A los arreglo se les llama por lo general tabla.

Arreglo Estructura de datos en la que a cada elemento se le asigna un índice único. Su representación

matemática es una matriz. Un array (más correctamente denominado vector), es un conjunto de

variables o registros del mismo tipo que puede estar almacenados en memoria principal o en memoria

auxiliar. Los array de 1 dimensión se denominan vectores, los de 2 o más dimensiones se denominan

matrices. La forma de acceder a los elementos del array es directo, es decir que el elemento deseado es

obtenido a partir de su índice.

2014


ARREGLOS UNIDIMENSIONALES

Son conocidos como vector. Un arreglo unidimensional llamado VICTOR, el cual consiste de N

elementos se puede representar

VICTOR(1) VICTOR (2) …… VICTOR(I) ….. VICTOR (N)Subíndices

Los subíndices o índices de un elemento designan su posición en el arreglo; en la notación que se

emplea aquí, un elemento en particular se define con el nombre del arreglo, seguido por el subíndice

del elemento entre paréntesis, es decir, VICTOR(I). Otras posibilidades para designar al elemento del

arreglo VICTOR con subíndice son: VICTO[I], VICTORI, VICTORI.

ARREGLOS MULTIDIMENSIONALES

Un arreglo de dos dimensiones, es un arreglo en el cual cada elemento es otro arreglo. Un arreglo

llamado B, el cual consiste de M elementos, cada uno de los cuales es un arreglo de N elementos se

puede representar como una tabla de M por N, como se muestra a continuación:

Ejemplo de un arreglo M por N

1 2 .. .. .. N2..M

Es necesario especificar dos subíndices para identificar un elemento individual en un arreglo

bidimensional. Por convención, el primer subíndice hace referencia al renglón.

Elemento B(I,J) en un arreglo

1 2 .. J .. N2…I B(I,J)…M

2014


Un arreglo se puede definir como un arreglo tridimensional, cuadrimensional, N-dimensional. Los

conceptos de suíndices, rango y número de elementos se pueden extender directamente de una y dos

dimensiones a arreglos de orden mayor. En general un arreglo N-dimensional requiere que los valores

de los N subíndices se especifiquen para identificar un elemento en particular del arreglo.

En programación, un vector, array, arreglo o alineación es un conjunto o agrupación de variables del

mismo tipo cuyo acceso se realiza por índices. Los vectores o arrays de dos o más dimensiones se

denominan matrices, que pueden tener tantas dimensiones como se desee; aunque lo correcto es

llamarlo arreglo (de memoria) ya que una variable de más de dos dimensiones, no cumple con las

características matemáticas de una matriz numérica.

ESTRUCTURAS DE REGISTRO

Los registros son los componentes básicos de los archivos y de las bases de datos. Un registro es una

colección finita y ordenada de elementos, posiblemente heterogéneos, que se tratan como una unidad.

Un registro se distingue de un arreglo en el hecho de que todos los elementos de un arreglo deben

tener la misma estructura, a diferencia de los elementos componentes del registro que pueden tener

diferentes estructuras de datos. Un registro se menciona algunas veces sólo como una estructura. Los

elementos de un registro son comúnmente llamados campos. Un campo es un área específica de un

registro utilizada para una clase particular de información.

FORMACION DE REGISTROS

Una unidad de información deriva, por lo menos, algo de su significado; a partir de sus relaciones con

otra información. La estructura de datos registro permite que un conjunto de elementos de

información, lógicamente relacionados, se pueda agrupar explícitamente. Por ejemplo, el campo de

tipo cadena llamado TITULO-DE-TAREA, con valor ‘ANALISTA’, no proporciona mucha

información por sí mismo. Sin embargo, se proporciona más información cuando el campo TITULO-

2014


DE-TAREA se acopla con otros campos lógicamente relacionados, como NUM-EMPLEADO, de tipo

cadena con valor ‘123456789’ y TARIFA-PAGO, de tipo decimal con valor 15.93. Estos elementos

heterogéneos no pueden constituir un arreglo porque son diferentes estructuras de datos. Sin embargo,

se pueden agrupar para constituir un registro de información del empleado como se muestra a

continuación:

TITULO-DE-TAREA NÚM-EMPLEADO TARIFA-PAGOANALISTA 123456789 15.93

LLAVES DE IDENTIFICACIÓN

Un registro, por lo general, contiene un campo que lo identifica. Un empleado se identifica por

ejemplo con su número de empleado. El campo que identifica el registro se llama campo llave. La

llave de un registro puede ser un elemento básico o bien uno grupal. Por ejemplo un registro de la

clase particular CURSO puede identificarse por el valor de sus campos DEPARTAMENTO,

NUMERO Y SECCIÓN.

ARCHIVOS

Se llama archivo a una colección de ocurrencias de registros lógicamente relacionados que se tratan

como una unidad.

Toda la información que se maneja dentro de un computador se encuentra almacenada en su memoria,

que en términos simples es una secuencia de caracteres (bytes) en donde se encuentran las

instrucciones y datos a los que se accede directamente a través del procesador del computador.

Los sistemas o métodos de organización de datos que permiten un almacenamiento eficiente de la

información en la memoria del computador son conocidos como estructuras de datos. Estos métodos

de organización constituyen las piezas básicas para la construcción de algoritmos complejos, y

permiten implementarlos de manera eficiente.

En el presente capítulo se presentan las estructuras de datos básicas como son arreglos, listas enlazadas

y árboles, con las cuales se implementarán posteriormente los tipos de datos abstractos.

2014


ARREGLOS

Un arreglo es una secuencia contigua de un número fijo de elementos homogéneos. En la siguiente

figura se muestra un arreglo de enteros con 10 elementos:

En Java un arreglo se define como:

tipo[] nombre = new tipo[n_elem];

donde tipo corresponde al tipo de los elementos que contendrá el arreglo (enteros, reales, caracteres,

etc..), nombre corresponde al nombre con el cual se denominará el arreglo, y n_elemcorresponde al

número de elementos que tendrá el arreglo. Para el caso del ejemplo presentado, la declaración del

arreglo de enteros es:

int[] arreglo = new int[10];

Para acceder a un elemento del arreglo se utiliza un índice que identifica a cada elemento de manera

única. Los índices en Java son números enteros correlativos y comienzan desde cero, por lo tanto, si el

arreglo contiene n_elem elementos el índice del último elemento del arreglo es n_elem-1. El siguiente

código muestra como se puede inicializar el arreglo del ejemplo, luego de ser declarado:

arreglo[0]=80; //el primer indice de los arreglos en Java es 0

arreglo[1]=45;

arreglo[2]=2;

arreglo[3]=21;

arreglo[4]=92;

arreglo[5]=17;

2014


arreglo[6]=5;

arreglo[7]=65;

arreglo[8]=14;

arreglo[9]=34; //el ultimo indice del arreglo es 10-1 = 9

También se puede declarar e inicializar el arreglo en una sola línea:

int[] arreglo={80, 45, 2, 21, 92, 17, 5, 65, 14, 34};

Una ventaja que tienen los arreglos es que el costo de acceso de un elemento del arreglo es constante,

es decir no hay diferencias de costo entre accesar el primer, el último o cualquier elemento del arreglo,

lo cual es muy eficiente. La desventaja es que es necesario definir a priori el tamaño del arreglo, lo

cual puede generar mucha pérdida de espacio en memoria si se definen arreglos muy grandes para

contener conjuntos pequeños de elementos (Nota: en Java es posible hacer crecer el tamaño de un

arreglo de manera dinámica).

PUNTEROS Y VARIABLES DE REFERENCIA

Un puntero es una variable que almacena la dirección de memoria de otra variable, es decir, almacena

el valor del lugar físico en la memoria en donde se encuentra almacenada dicha variable. Si se imagina

que la memoria del computador es un gran arreglo de bytes, la dirección de memoria correspondería al

índice de los casilleros de dicho arreglo, que es precisamente lo que se almacena en el puntero.

En algunos lenguajes de programación, por ejemplo C, es posible declarar explícitamente punteros

para distintos tipos de variables, e incluso es posible realizar aritmética de punteros para realizar

operaciones de manera muy eficiente, a cambio de "oscurecer" el código del programa y con una alta

probabilidad de cometer errores de programación díficiles de detectar.

En Java no se puede declarar punteros de manera explícita ni tampoco realizar aritmética de punteros.

Por lo tanto es imposible en Java tener un puntero a cualquiera de los tipos primitivos: enteros, reales,

caracteres y booleanos. Los strings y arreglos no son tipos primitivos en Java.

2014


Una variable de referencia, o simplemente una referencia, es una variable que almacena la dirección

de memoria en donde se ubica un objeto. Nótese que si bien la definición es prácticamente idéntica a

la de puntero, la diferencia radica en que una referencia sólo puede apuntar a objetos residentes en

memoria, lo cual excluye a los tipos primitivos. A partir de esta definición se puede concluir que toda

variable en Java, que no sea de tipo primitivo, es una referencia.

Por ejemplo, todas las clases en Java heredan de la clase Object. Una instancia de ésta clase se declara

como:

Object aux=new Object();

La variable aux es una referencia a un objeto de la clase Object que permite saber la ubicación de

dicho objeto dentro de la memoria, información suficiente para poder operar con él. Intuitivamente, la

referencia es como una "flecha" que nos indica la posición del objeto que apunta:

LISTAS ENLAZADAS

Una lista enlazada es una serie de nodos, conectados entre sí a través de una referencia, en donde se

almacena la información de los elementos de la lista. Por lo tanto, los nodos de una lista enlazada se

componen de dos partes principales:

class NodoLista

{

2014


Object elemento;

NodoLista siguiente;

}

La referencia contenida en el nodo de una lista se denomina siguiente, pues indica en dónde se

encuentra el siguiente elemento de la lista. El último elemento de la lista no tiene nodo siguiente, por

lo que se dice que la referencia siguiente del último elemento es null (nula).

La siguiente figura muestra un ejemplo de una lista enlazada cuyos elementos son strings:

La referencia lista indica la posición del primer elemento de la lista y permite acceder a todos los

elementos de ésta: basta con seguir las referencias al nodo siguiente para recorrer la lista.

NodoLista aux=lista;

aux=aux.siguiente;

2014


Siguiendo con el ejemplo anterior, para insertar un nuevo nodo justo delante del nodo referenciado

por aux se deben modificar las referencias siguiente del nodo aux y del nodo a insertar.

NodoLista nuevo=new NodoLista(...);

//"nuevo" es la referencia del nodo a insertar en la lista

nuevo.siguiente=aux.siguiente;

aux.siguiente=nuevo;

//Notese que no es lo mismo realizar los cambios de referencia

//en un orden distinto al presentado, puesto que en ese caso

//se "pierde" la lista desde el nodo siguiente a aux

El procedimiento presentado a continuación es un ejemplo de cómo se programa el recorrido de una

lista enlazada. Se supondrá que los objetos almacenados en cada nodo son strings:

void recorrido(NodoLista lista)

{

NodoLista aux=lista;

2014


while (aux!=null)

{

System.out.println(aux.elemento);

aux=aux.siguiente;

}

}

Para invertir el orden de la lista, es decir, que el último elemento de la lista ahora sea el primero, que

el penúltimo elemento de la lista ahora sea el segundo, etc..., modificando sólo las referencias y no el

contenido de los nodos, es necesario realizar una sola pasada por la lista, y en cada nodo visitado se

modifica la referencia siguiente para que apunte al nodo anterior. Es necesario mantener referencias

auxiliares para acordarse en donde se encuentra el nodo anterior y el resto de la lista que aún no ha

sido modificada:

void invertir(NodoLista lista)

{

NodoLista siguiente=lista;

NodoLista anterior=null;

while(lista!=null)

{

siguiente=lista.siguiente;

lista.siguiente=anterior;

anterior=lista;

2014


lista=siguiente;

}

}

La implementación vista de los nodos también se conoce como lista de enlace simple, dado que

sólo contiene una referencia al nodo siguiente y por lo tanto sólo puede recorrerse en un solo sentido.

En una lista de doble enlace se agrega una segunda referencia al nodo previo, lo que permite recorrer

la lista en ambos sentidos, y en general se implementa con una referencia al primer elemento y otra

referencia al último elemento.

Una lista circular es aquella en donde la referencia siguiente del último nodo en vez de

ser null apunta al primer nodo de la lista. El concepto se aplica tanto a listas de enlace simple como

doblemente enlazadas.

En muchas aplicaciones que utilizan listas enlazadas es útil contar con un nodo cabecera,

tambien conocido como dummy o header, que es un nodo "falso", ya que no contiene información

relevante, y su referencia siguiente apunta al primer elemento de la lista. Al utilizar un nodo cabecera

siempre es posible definir un nodo previo a cualquier nodo de la lista, definiendo que el previo al

primer elemento es la cabecera.

2014


Si se utiliza un nodo cabecera en una lista de doble enlace ya no es necesario contar con las

referencias primero y último, puesto que el nodo cabecera tiene ambas referencias: su

referenciasiguiente es el primer elemento de la lista, y su referencia anterior es el último elemento de

la lista. De esta forma la lista de doble enlace queda circular de una manera natural.

ÁRBOLES

Un árbol se define como una colección de nodos organizados en forma recursiva. Cuando hay 0

nodos se dice que el árbol esta vacío, en caso contrario el árbol consiste en un nodo denominado raíz,

el cual tiene 0 o más referencias a otros árboles, conocidos como subárboles. Las raíces de los

subárboles se denominan hijos de la raíz, y consecuentemente la raíz se denomina padre de las raíces

de sus subárboles. Una visión gráfica de esta definición recursiva se muestra en la siguiente figura:

2014


Los nodos que no poseen hijos se denominan hojas. Dos nodos que tienen el padre en común se

denominan hermanos.

Un camino entre un nodo n1 y un nodo nk está definido como la secuencia de nodos n1, n2,

..., nk tal que ni es padre de ni+1, 1 <= i < k. El largo del camino es el número de referencias que

componen el camino, que para el ejemplo son k-1. Existe un camino desde cada nodo del árbol a sí

mismo y es de largo 0. Nótese que en un árbol existe un único camino desde la raíz hasta cualquier

otro nodo del árbol. A partir del concepto de camino se definen los conceptos

de ancestro y descendiente: un nodo n es ancestro de un nodo m si existe un camino desde n a m; un

nodo n es descendiente de un nodo m si existe un camino desde m a n.

Se define la profundidad del nodo nk como el largo del camino entre la raíz del arbol y el

nodo nk. Esto implica que la profundidad de la raíz es siempre 0. La altura de un nodo nk es el máximo

largo de camino desde nk hasta alguna hoja. Esto implica que la altura de toda hoja es 0. La altura de

un árbol es igual a la altura de la raíz, y tiene el mismo valor que la profundidad de la hoja más

profunda. La altura de un árbol vacío se define como -1.

La siguiente figura muestra un ejemplo de los conceptos previamente descritos:

2014


A es la raíz del árbol.

A es padre de B, C y D.

E y F son hermanos, puesto que ambos son hijos de B.

E, J, K, L, C, P, Q, H, N y O son las hojas del árbol.

El camino desde A a J es único, lo conforman los nodos A-B-F-J y es de largo 3.

D es ancestro de P, y por lo tanto P es descendiente de D.

L no es descendiente de C, puesto que no existe un camino desde C a L.

La profundidad de C es 1, de F es 2 y de Q es 4.

La altura de C es 0, de F es 1 y de D es 3.

La altura del árbol es 4 (largo del camino entre la raíz A y la hoja más profunda, P o Q).

ÁRBOLES BINARIOS

Un árbol binario es un árbol en donde cada nodo posee 2 referencias a subárboles (ni más, ni

menos). En general, dichas referencias se denominan izquierda y derecha, y consecuentemente se

define el subárbol izquierdo y subárbol derecho del arbol.

2014


En este caso, la implementacion del nodo de un árbol binario es como sigue:

class NodoArbolBinario

{

Object elemento;

NodoArbolBinario izq;

NodoArbolBinario der;

}

Los nodos en sí que conforman un árbol binario se denominan nodos internos, y todas las

referencias que son null se denominan nodos externos.

2014


PROPIEDADES DE LOS ÁRBOLES BINARIOS

Propiedad 1:

Si se define i = número de nodos internos, e = número de nodos externos, entonces se tiene

que:

e = i+1

Demostración: inducción sobre i (ejercicio).

Propiedad 2:

Sea n = número de nodos internos. Se define:

In = suma del largo de los caminos desde la raíz a cada nodo interno (largo de caminos internos).

En = suma del largo de los caminos desde la raíz a cada nodo externo (largo de caminos

externos).

Se tiene que:

En = In+2n

Demostración: inducción sobre n (ejercicio).

2014


Propiedad 3:

¿Cuántos árboles binarios distintos se pueden construir con n nodos internos?

n bn

0 1

1 1

2 2

3 5

¿bn?

Por ejemplo: b4 = b0*b3 + b1*b2 + b2*b1 + b3*b0 = 5 + 2 + 2 + 5 = 14.

Este tipo de ecuaciones se puede resolver y la solución es la siguiente:

La serie de numeros que genera bn se conoce como números de Catalan. Asintóticamente:

Ejemplo: árboles de expresiones matemáticas

La siguiente figura muestra un ejemplo de un árbol de expresiones matemáticas. En un árbol de

expresiones las hojas corresponden a los operandos de la expresión (variables o constantes), mientras

2014


que los nodos restantes contienen operadores. Dado que los operadores matemáticos son binarios (o

unarios como en el caso del operador signo -), un árbol de expresiones resulta ser un árbol binario.

Un árbol de expresiones se puede evaluar de la siguiente forma:

Si la raíz del árbol es una constante o una variable se retorna el valor de ésta.

Si la raíz resulta ser un operador, entonces recursivamente se evalúan los subárboles izquierdo y

derecho, y se retorna el valor que resulta al operar los valores obtenidos de las evaluaciones de los

subárboles con el operador respectivo.

RECORRIDOS DE ÁRBOLES BINARIOS

Existen tres formas principales para recorrer un árbol binario en forma recursiva. Estas son:

Preorden: raíz - subárbol izquierdo - subárbol derecho.

Inorden: subárbol izquierdo - raiz - subárbol derecho.

Postorden: subárbol izquierdo - subárbol derecho - raíz.

Por ejemplo, al recorrer el árbol de expresiones anterior en preorden se obtiene:

* + a b - c d

Al recorrer el árbol en inorden se obtiene:

2014


a + b * c - d

Al recorrer el árbol en postorden se obtiene:

a b + c d - *

La expresión que se obtiene con el recorrido en postorden se conoce como notación polaca.

ÁRBOLES GENERALES

En un árbol general cada nodo puede poseer un número indeterminado de hijos. La

implementación de los nodos en este caso se realiza de la siguiente manera: como no se sabe de

antemano cuantos hijos tiene un nodo en particular se utilizan dos referencias, una a su primer hijo y

otra a su hermano más cercano. La raíz del árbol necesariamente tiene la referencia a su hermano

como null.

class NodoArbolGeneral

{

Object elemento;

NodoArbolGeneral hijo;

NodoArbolGeneral hermano;

}

2014


Nótese que todo árbol general puede representarse como un árbol binario, con la salvedad que el

hijo derecho de la raíz es siempre null. Si se permite que la raíz del árbol tenga hermanos, lo que se

conoce como bosque, entonces se tiene que el conjunto de los bosques generales es isomorfo al

conjunto de los árboles binarios. En efecto, las propiedades vistas en los árboles binarios se siguen

cumpliendo en los árboles generales.

BIBLIOGRAFIA

http://www.aprenderaprogramar.com/

http://oasis.cisc-ug.org/pages1/descargas.htm

http://www.lawebdelprogramador.com

http://www.aulaclic.net/

COMISION REVISORA:ING. WALTHER VARGAS GONZALEZ

ING. JOFFRE VAZQUEZ DEL ROSARIO

TLGO. SOLANGE GOMEZ SALTOS

Guia Estructura Datos 2

Documents

Transcript of Guia Estructura Datos 2