Estructura 1 de Datos- Pilas, Colas, Arbole s

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas

ESTRUCTURA DE DATOS EN JAVAYerson Carhuallanqui Palian

Hecho con:

FlashLinux - 2009 Página | 1

MARZO / 2009

Todo lo que se necesita saber sobre:

pilas ~ colas ~ arboles

Todo esto implementado en código java.

• Capitulo I: Pila

• capitulo II: Cola

• capitulo III: Arbol

• Ejemplos aplicativos

“Facultad de Ingeniería de Sistemas”

Se otorga permiso para copiar, distribuir y/o modificar este

documento bajo los términos de la Licencia Commons Creative

11

“El Software Libre sin dudas revolucionó el mundo, nos corresponde a nosotros colocarlo en el puesto que se merece.”

Primera Edicion- no revisado


FlashLinux 2009

Estructura de Datos en java Pilas ~ Colas ~ Árboles

Yerson Carhuallanqui palian




A mis padres: Cesar y Florencia,

Las personas que con su ternura

Y comprensión hizo de mí,

Una persona de bien.

A mis hermanas,

Por llenarme de alegría y felicidad


Reconocimiento-Compartir bajo la misma licencia

Usted es libre de:

• Copiar, distribuir y comunicar públicamente la obra.• Hacer obras derivadas.

Bajo las condiciones siguientes:

Reconocimiento:

Debe reconocer los créditos de la obra de la manera especificada por el autor o el licenciador (pero no de una manera que sugiera que tiene su apoyo o apoyan el uso que hace su obra).

Compartir bajo la misma licencia:

Si altera o transforma esta obra, o genera una obra derivada solo puede distribuir la obra bajo una licencia idéntica a ésta.

• Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos de la licencia de esta obra.

• Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de los derechos del autor.

• Nada en esta licencia menoscaba o restringe los derechos morales del autor.



CONTENIDO

CAPITULO I: PILAS

1. Pila

1.1. Operaciones básica1.2. Arquitectura básica de una pila1.3. Implementación

CAPITULO II: COLAS

2. Cola

2.1. Usos concretos de la cola2.2. Operaciones básica2.3. Variables de instancia en la implementación2.4. Implementación

CAPITULO III: ARBOLES

3. Arbol

3.1. Nomenclatura de los árboles3.2. Árbol binario.3.3. Convirtiendo a un árbol binario3.4. Implementación

CAPITULO IV: EJEMPLOS

4.1. Ejemplos 1: Pila4.2. Ejemplos 2: Cola4.3. Ejemplos 3: Arboles


07

15

22

31


P R E FA C I O

Dar el primer paso siempre es importante, pero también estoy seguro que igual o más importantes aún serán los pasos siguientes, porque éstos reflejarán una continuidad en el compromiso adquirido en este mundo donde el principal objetivo debe ser brindar lo mejor de nosotros mismos.¿Quién lo iba a decir? ¿Yo escribiendo mi propio manual?, Ahora todo es una realidad. Mucho se ha escrito acerca de que el aprendizaje no es accidental sino el resultado directo de esfuerzo y mucha dedicación, muchos ven el aprendizaje como una actividad manejable, no por el estímulo, sino por el propio estudiante, quien debe querer aprender y participar en el proceso de aprendizaje, si es que quiere lograr un progreso real. Es importante que el estudiante reflexione acerca de lo anteriormente expuesto, cuando se encuentre en el proceso de aprendizaje de esta asignatura. Muchos jóvenes leen libros y manuales acerca de esta asignatura, tal vez por el afán de entender mejor los temas tratados en clase, pero yo no fui uno de ellos. Yo intento plasmar todo lo aprendido en estas hojas. Para facilitar el proceso de aprendizaje en el mundo de la programación, se ha preparado este material de apoyo, de fácil lectura, donde se han considerado puntos esenciales tales como: Los aspectos que deben ser aprendidos, la forma en que deben ser presentados y secuenciados, qué ideas deben enseñarse antes que otras, la forma más práctica de presentar cada concepto; todo esto para que el estudiante logre los objetivos propuestos en la asignatura. ¡Éxito¡



Para entender claramente este capítulo, primero tendremos que recordar lo que es Listas, ya que una pila es un tipo de Lista.Recordemos, entonces, lo que es una Lista:Una lista se define como una serie de N elementos E1, E2, ..., Ek, ordenados de manera consecutiva. Es decir, el elemento Ek (que se denomina elemento k-ésimo) es previo al elemento Ek+1. Si la lista contiene 0 elementos se denomina como lista vacía.

Las operaciones que se pueden realizar en la lista son: insertar un elemento en la posición k, borrar el k- ésimo elemento, buscar un elemento dentro de la lista y preguntar si la lista está vacía. Etc.FlashLinux - 2009 Página | 7

CAPITULO I: PILAS

¿Qué es Estructuras de Datos?

Las estructuras de datos son, como su nombre lo indica, estructuras que guardan datos. Pero no son solamente eso, ya que también tienen operaciones básicas para

acceder e insertar nuevos datos, lo que las hace eficientes y muy útiles al crear cierto tipo de programas.


1. PILAUna pila (stack o pushdown en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos.Las pilas son unas de las estructuras de datos más usadas dentro de la programación. En este caso se puede usar el famoso dicho: “Los primeros serán los últimos y los últimos serán los primeros”. Una pila es una lista de elementos en el que se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar (pop), que retira el último elemento apilado.En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado cima). La operación desapilar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser la nuevo cima.

Figura 1.1

En la figura 1.1, el elemento E ha sido el último en ingresar a la pila. Si se quiere eliminar un elemento de la pila, éste debe ser el último que ingresó. O sea el último en entrar es el primero en salir.Para explicar mejor el concepto de pilas, tomemos el siguiente caso:Supongamos que somos personas que nos apasiona leer libros (Ojo: solo estamos suponiendo), Si usted tiene un libro de “Programacion” en la mano y deseas ubicarlo en un lugar cualquiera, en este caso en tu escritorio, lo colocarías sin ningún problema. (Figura 1.2)

Figura 1.2


Programació

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de SistemasAhora bien, ya tenemos ubicado nuestro primer libro. A continuación ubicamos un segundo libro (estadística) encima del primer libro; pues bien, este proceso de ubicar un libro encima del otro se llama “apilar”. Otro concepto que vamos a utilizar es la cima de la pila; es decir, el valor que esta al inicio de la pila, en el grafico siguiente la cima es el libro de “estadística” y si apilamos un tercer libro la cima vendría ser este tercer libro. Veamos cómo va quedando nuestro gráfico (Figura 1.3).

Figura 1.3

Bueno con esto creo que se entiende mejor lo que está escrito líneas arriba:“El último que entra es el primero que sale”, Claro que esto se cumple, pues usted va a poder retirar o desapilar el último libro que apiló. Y si por algún motivo deseas retirar el libro de programación lo primero que tendrás que hacer es desapilar el libro de estadística. Además de esto usted solo puede apilar en la cima de la pila.Ahora podemos representar nuestros libros como una pila:Si lo llevamos el caso anterior a una pila, quedaría de la siguiente manera (Figura1.4).El primer libro que apilamos es el libro de programación, luego el segundo libro apilado fué de estadística, aquí se puede observar claramente que la inserción de elementos en la pila se realiza por la cima o inicio, como ya lo habíamos mencionado anteriormente.

Figura1.4

Para entender mejor, la figura anterior se puede visualizar de la siguiente manera:

Figura 1.5


CIMA

ProgramacióEstadística


1.1. OPERACIONES BÁSICASLas pilas proveen de las siguientes operaciones:apilar(x) Inserta el elemento x en el tope o cima de la pila.

desapilar() Elimina el elemento que se encuentra en la cima de la pila.cima() retorna el elemento que se encuentre en el tope o cima de la pila, pero sin eliminarlo de ésta (top en inglés).anula() Borra todos los elementos de la pila.estaVacia() Retorna verdadero si la pila no contiene elementos, falso en caso contrario.

Nota: Algunos autores definen desapilar como sacar el elemento del tope de la pila y retornarlo.1.2. Arquitectura básica de una pilaUna pila típica es un área de la memoria de los computadores con un origen fijo y un tamaño variable. Al principio, el tamaño de la pila es cero. Un puntero de pila, por lo general en forma de un registro de hardware, apunta a la más reciente localización en la pila; cuando la pila tiene un tamaño de cero, el puntero de pila de puntos en el origen de la pila.Las dos operaciones aplicables a todas las pilas son:

• Una operación apilar, en el que un elemento de datos se coloca en el lugar apuntado por el puntero de pila, y la dirección en el puntero de pila se ajusta por el tamaño de los datos de partida. • Una operación desapilar: un elemento de datos en la ubicación actual apuntado por el puntero de pila es eliminado, y el puntero de pila se ajusta por el tamaño de los datos de partida. Hay muchas variaciones en el principio básico de las operaciones de pila. Cada pila tiene un lugar fijo en la memoria en la que comienza. Como los datos se añadirán a la pila, el puntero de pila es desplazado para indicar el estado actual de la pila, que se expande lejos del origen (ya sea hacia arriba o hacia abajo, dependiendo de la aplicación concreta).

1.3. IMPLEMENTACIÓN Para poder implementar nuestro programa, haremos uso de un software; en nuestro caso usaremos NetBeans IDE 6.0. FlashLinux - 2009 Página | 10

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de SistemasTambién se puede utilizar otro software como JCreator que también nos permite implementar código java, pero lo que realmente nos interesa es la implementación del código y no el software.Bueno lo que haremos será crear la clase pila e implementar las operaciones básica que realiza, como ya sabemos en una pila se puede insertar elementos al que nosotros lo llamamos apilar, podemos desapilar, obtener el valor de la cima, anular o borrar toda la pila, y saber si la pila está vacía o llena.Entonces ahí vamos, espero que no se pierdan.EJEMPLO 01:Implementar un programa que almacene números enteros positivos, el programa debe realizar las operaciones básicas de una pila (anular, apilar, desapilar, mostrar la cima, verificar si la pila está vacía, mostrar el contenido).Ejemplo: si ingresamos los números 1, 2, 3 y 4 debe quedar de la siguiente manera.

Figura 1.6Implementación de la clase pila: import javax.swing.JOptionPane; public class pila {// creacion de la clase Nodo.class Nodo { int nombre; // para el valor que va almacenarNodo sgte; // apuntador al siguiente Nodo}Nodo inicio = null;Nodo fin = null;

//elimina todo los elementos de la pila.public void anula(){ inicio = fin = null;}FlashLinux - 2009 Página | 11


//Implementacion del metodo apilar que nos permite insertar un elemento en la pila, en este caso como se trata de una pila insertamos en el inicio o cima de la pila.public void apilar(int x) { // creamos un Nodo temporal para almacenar el valor que vamos a insertar.Nodo temp = new Nodo();temp.nombre = x;if (inicio == null){ fin = inicio;}temp.sgte = inicio;inicio = temp;}// Implementacion del metodo desapilar, que nos permite quitar un elemento de la pila, en este caso quitamos el elemento que esta en la cimapublic void desapilar(){ if (inicio == null){JOptionPane.showMessageDialog(null, "Pila vacía...");} else { inicio = inicio.sgte;}}//Implementacion del metodo CIMA, que nos retorna el valor de la cima como un numero entero.public int cima(){ if (inicio == null) { // si la pila esta vacíareturn (-1);} else { // si la pila no se encuentra vacia, retornar el valor de la cima.return inicio.nombre;}}//Implementacion del metodo estaVacio.public boolean estaVacio(){ if (inicio == null){// si la pila está vacio retornar verdadero.FlashLinux - 2009 Página | 12


return true;} else { // si no retornar falso.return false;}}//Implementacion del metodo contenido, que nos permite visualizar el contenido de la pila.public void contenido(){ Nodo temp = inicio;String cad = "El contenido de la pila es:\n";while (temp != null){ cad += temp.nombre + "\n ";temp = temp.sgte;}JOptionPane.showMessageDialog(null, cad);} }Implementación de la Clase PruebaPila que utiliza la clase pila:

import javax.swing.JOptionPane;public class PruebaPila{ public static void main(String[] args){pila p = new pila();int nombre;//Ingresamos los valores a la pila mediante el metodo apilar. for (int i = 1; i <= 4; i++){ nombre = Integer.parseInt(JOptionPane.showInputDialog("Ingrese valor a apilar: "));p.apilar(nombre);}//Mostramos el contenido de la pila. p.contenido();



//Obtenemos el valor de la cima. JOptionPane.showMessageDialog(null, "La cima es: " + p.cima());//Desapilamos un elemento de la pila, en este caso se desapila la cima.p.desapilar();p.contenido(); // verificamos si la pila está vacio... JOptionPane.showMessageDialog(null, "¿La pila está vacio?: " + p.estaVacio());//Utilizamos el metodo anula para eliminar todo el contenido de la pila.p.anula();// otra vez verificamos si la pila está vacio (deberia retornar verdadero ya que el contenido de la pila fue eliminada) JOptionPane.showMessageDialog(null, "¿La pila está vacio?: " + p.estaVacio());}}



COLAS

2. COLAEl nombre más común de ésta estructura de datos es “cola” aunque yo la preferiría llamar “fila” por razones obvias.Esta estructura de datos funciona como una fila de turnos, al primero que llega se le atiende primero y al último que llega se le atiende al último. Tal y cómo en la taquilla del cine. De esta manera, al acceder a una cola, se accede al primer elemento que se introdujo, luego al segundo, luego al tercero y así sucesivamente.

También se conoce a las colas como listas FIFO (FIRST IN - FIRST OUT: el primero que entra es el primero que sale). Afortunadamente en un sistema informático no se cuela nadie salvo que el programador lo diga.Esto se entiende de la siguiente manera: El primer elemento en entrar es el primero en salir. (Figura 2.1)


CAPITULO II: COLAS

Las colas se utilizan en sistemas informáticos, transportes, operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como

datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura

de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma

de listas enlazadas.

http://es.wikipedia.org/wiki/Inform%C3%83%C2%A1tica

http://es.wikipedia.org/wiki/Transporte

http://es.wikipedia.org/wiki/Investigaci%C3%83%C2%B3n

http://es.wikipedia.org/wiki/Programaci%C3%83%C2%B3n_orientada_a_objetos


Figura 2.1Para aclararlo, se muestran una serie de gráficos explicativos, partiendo de un cola vacía, es decir, una cola nulo.

Cola vacía:

Se encola un 3.

Se desencola el 3; ahora se tiene una cola vacía.

Se encolan el 5 y el 7. Se obtiene una cola contenida.

Si se desencola se obtiene el 5.

2.1. Usos concretos de la colaLa particularidad de una estructura de datos de cola es el hecho de que sólo podemos acceder al primer y al último elemento de la estructura. Así mismo, los elementos sólo se pueden eliminar por el principio y sólo se pueden añadir por el final de la cola.Ejemplos de colas en la vida real serían: personas comprando en un supermercado, esperando para entrar a ver un partido de béisbol, esperando en el cine para ver una película, una pequeña peluquería, etc. La idea esencial es que son todas líneas de espera.En estos casos, el primer elemento de la lista realiza su función (pagar comida, pagar entrada para el partido o para el cine) y deja la cola. Este movimiento está representado en la cola por la función pop o desencolar.


“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de SistemasCada vez que otro elemento se añade a la lista de espera se añaden al final de la cola representando la función push o encolar. Hay otras funciones auxiliares para ver el tamaño de la cola (size), para ver si está vacía en el caso de que no haya nadie esperando (empty) o para ver el primer elemento de la cola (frente).Para que este concepto quede claro a continuación de presento un caso:Supogamos que somos cliente de un banco.Generalmente, cuando uno va a realizar cualquier operación bancaria, nos encontramos a muchas personas esperando ser atendidas, éstas personas esperan ordenadamente según la orden de llegada de cada cliente; es decir, si un cliente llegó primero al banco será el primero en ser atendida, mientras que los demás deben esperar su turno. Algo similar ocurre en la implementación de

colas, los elementos que se insertan se realizan al final de la cola, mientras que los elementos que se van a eliminar se realizan al inicio o al frente de dicha cola.Bueno sigamos con nuestro caso, supongamos que el cliente “Cesar” llega al banco, seguidamente llega el siguiente cliente “Juan”, si ordenamos según la orden de llegada se observa la siguiente figura.

Figura 2.2

Si lo representamos en una cola, la figura sería el siguiente:

Figura 2.3

¿Qué pasa con la cola si llega el tercer cliente marcos? ¿Donde se inserta el elemento?


“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de SistemasComo ya mencionamos líneas arriba, en una cola los elementos se insertan al final, por lo que la cola quedaría de la siguiente manera:

Figura 2.4

2.2. OPERACIONES BÁSICASLas colas poseen las siguientes operaciones básicas:encolar(x) Inserta el elemento x al final de la cola

desencolar() Elimina el elemento que se encuentra al frente de la cola.frente() retorna el elemento que se encuentre en el frente de la cola, pero sin eliminarlo de ésta (top en inglés).anula() Borra todos los elementos de la pila.estaVacia() Retorna verdadero si la pila no contiene elementos, falso en caso contrario.

2.3. VARIABLES DE INSTANCIA EN LA IMPLEMENTACIÓN

• Inicio: indica el índice de la posición del primer elemento de la cola, es decir, la posición el elemento a retornar cuando se invoque sacar.• Fin: indica el índice de la posición de último elemento de la cola. Si se invoca encolar, el elemento debe ser insertado en el casillero siguiente al que indica la variable.

2.4. IMPLEMENTACIÓNAhora implementaremos la clase cola y sus principales operaciones que realiza: De la misma manera que realizamos la implementacion de pilas, ahora realizamos en colas.Como en el caso anterior, nuestra cola tambien almacenará numeros enteros.FlashLinux - 2009 Página | 18


EJEMPLO 01:

Implementación de la clase cola:

//Implementacion y demostracion basica de Colas. import javax.swing.JOptionPane;public class Cola {//Creacion de la clase Nodoclass Nodo{ int nombre;Nodo sgte;}Nodo inicio = null;Nodo fin = null;//Implementacion del metodo anula, que limpia toda la cola.public void anula() {inicio = fin = null;}//metodo que inserta un elemento al final de la cola.public void encolar(int x){ Nodo temp = new Nodo(); // creamos un nuevo Nodo temporal.if (temp == null) {JOptionPane.showMessageDialog(null, "Error de asignacion...");} else { temp.nombre = x;// Poner al final de la colaif (fin != null) {fin.sgte = temp;}fin = temp;temp.sgte = null;if (inicio == null){inicio = fin;}}}FlashLinux - 2009 Página | 19


//metodo que elimina el valor que esta al frente.public void desencolar() {if (inicio == null) {JOptionPane.showMessageDialog(null, "Cola vacía...");} else { // Quitar del principio de la colainicio = inicio.sgte;}}// metodo que retorna el valor de la cola del frente.public int frente() {if (inicio == null){ // si la cola es vacía retorna -1JOptionPane.showMessageDialog(null, "Cola vacía...");return (-1);} else { // retorna el valor que esta al frente...return inicio.nombre;}}//metodo que nos permite verificar si la pila esta vacia o contenidopublic boolean estaVacio(){if (inicio == null){// si al pila se encuentra vacion retornar verdadero.return true;}else { return false;}}//muestra el contenido de la colapublic void contenido() {Nodo temp = inicio;String cad = "Impresión de la cola:\n";while (temp != null) {cad += temp.nombre + " --> ";temp = temp.sgte;}JOptionPane.showMessageDialog(null, cad);} }


“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de SistemasImplementación de la clase PruebaCola, que utiliza la clase cola: import javax.swing.JOptionPane;public class PruebaCola {public static void main(String[] args) {Cola C = new Cola();int nombre;//Ingresamos los valores a la pila mediante el metodo apilar.for (int i = 1; i <= 4; i++) {nombre = Integer.parseInt(JOptionPane.showInputDialog("Ingrese valor a encolar: "));C.encolar(nombre);}//Mostramos el contenido de la pila.C.contenido();//Obtenemos el valor de la cima.JOptionPane.showMessageDialog(null,"El valor que esta al frente es: " + C.frente());//Desapilamos un elemento de la pila, en este caso se desapila la cima.C.desencolar();C.contenido();// verificamos si la pila está vacio...JOptionPane.showMessageDialog(null, "¿La cola está vacio?: " + C.estaVacio());

//Utilizamos el metodo anula para eliminar todo el contenido de la pila.C.anula();// otra vez verificamos si la pila está vacio (deberia retornar verdadero yaque el contenido de la pila fue eliminada)JOptionPane.showMessageDialog(null, "Ahora, ¿La cola está vacio?: " + C.estaVacio());}}



3. ARBOLBueno, vamos avanzando:Un árbol es una estructura de datos jerárquica, en que cada elemento está unido a otro número finito de elementos u objetos llamados Nodos, es importante mencionar que en los árboles, al igual que en las listas, ningún elemento apunta a alguno de sus predecesores.“...Uno de los Nodos que conforman el árbol es conocido como raíz. Además se crea una relación o parentesco entre los nodos dando lugar a términos como padre, hijo, hermano, antecesor, sucesor, ancestro, etc.” 1Si lo que queremos el verlo de forma gráfica, entonces podemos representarlo mediante grafos, que es la mas utilizada y que a su vez se puede entender mejor la estructura de un árbol.

Figura 3.1 [GRAFO]

1 Estructura de datos en Java - Abraham Gamarra moreno – pág. 107FlashLinux - 2009 Página | 22

CAPITULO III:

ÁRBOLES

A

B C

D E F G

H j kI

Nodo Raíz


3.1. Nomenclatura de los árbolesAquí va la nomenclatura de los árboles:• A un conjunto de árboles se le llama bosque.• A cada elemento del árbol se le llama nodo.• A cada apuntador entre dos nodos se le llama rama.• Un nodo A es padre de nodo B descendiendo por una rama de A se puede llegar a B.• Un nodo A es hijo de B si descendiendo por la rama de B se puede llegar a A.• Una hoja es un nodo que no tiene hijos.• Un nodo es raíz si no tiene padres.• Todos los nodos que son descendientes directos (hijos) de un mismo nodo (padre), son hermanos.• Todo nodo que no es raíz, ni terminal u hoja se conoce con el nombre de

interior.• Grado es el número de descendientes directos de un determinado nodo. Grado del árbol es el máximo grado de todos los nodos del árbol.Para que desciendan de las nubes, vamos a explicarlo con un ejemplo: Tomemos el siguiente grafo como nuestro árbol y definamos la nomenclatura de dicho árbol.

• Como ya sabemos, el elemento A es la raíz del árbol.• B es hijo de A, C es hijo de A, D es hijo de B, E es hijo de B, etc...• B y C son hermanos, D y E son hermanos, K y H son hermanos, etc...• A es padre de B y C, B es padre de D y E, etc...• K, H, E, I, J y G son nodos terminales u Hojas.• El grado del nodo B es 2.• El grado del árbol es 3.



3.2. Árbol binario.

• Es un conjunto finito de elementos que está vacío o divido en tres subconjuntos separados.• El primer subconjunto contiene un elemento único llamado raíz del árbol.• Los otros 2 subconjuntos son por sí mismo árboles binarios y se les conoce como subárboles izquierdo y derecho del árbol original.

Figura 3.3. [Definición de un árbol binario]

Si lo representamos como un Nodo, el gráfico sería de la siguiente manera:

Figura 3.4. [Árbol representado como un Nodo]

3.3. Convirtiendo a un árbol binarioPara implementar arboles en java y en cualquier otro lenguaje de programación, es preferible que nuestro árbol tenga la estructura de un árbol binario, para la fácil manipulación de los Nodos; ya que un árbol binario presenta solo dos subarboles(izquierda y derecha) a diferencia de los arboles generales que son mas complejos.FlashLinux - 2009 Página | 24

A

B C

Nodo raíz Subarbol izquierdo

A

B C

Nodo raíz

null null null null

Izquierdo DerechoDerechoIzquierda Derecho Izquierdo

Subarbol Derecho


Los pasos que se deben aplicar para lograr la conversión del árbol general al árbol binario son los siguientes:Tomemos el arbol general de la figura 3.5 para convertirlo en un arbol binario.

Figura 3.5

• Cuando hay una relacion de padre a hijo, debe enlazarse en forma vertical el nodo padre con el hijo que se encuentra más a la izquierda. Además de esto, debe eliminarse el vínculo de ese padre con el resto de sus hijos.• Todo los Nodos que desciendan del nodo padre, es decir, los nodos hermanos deben enlazarse en forma horizontal.Finalmente nuestro arbol general quedará de la siguiente manera:

Figura 3.6


A

C D

H J

N

I

L M

O P

B

E F

K

G


• Ahora debe rotarse el diagrama resultante, aproximadamente 45 grados hacía la ízquierda, y así se obtendrá el árbol bínarío correspondiente.

Figura 3.7 [Árbol binario luego de girar 45º]

3.4. Recorridos de un árbolEl recorrido de un árbol es algo fundamental en la rama de los algoritmos, seguramente el lector estará pensando en saltarse esta parte, porque ¿Qué tanta ciencia puede tener recorrer un árbol? ¿No basta con poner que recorra todos los nodos y ya?.Pues la verdad es que no, ya que algunos algoritmos de ordenamiento utilizan el recorrido en orden, mientras que para buscar soluciones eficientes se utiliza el recorrido en preorden y para otro tipo de algoritmos que requiere cierta liberación de memoria es necesario el recorrido en postorden.3.4.1. Recorrido en Orden (Inorden)Llamado también recorrido en orden simétrico; en este caso se visita primero el nodo izquierdo, luego el actual y finalmente el derecho, se implementaría algo así como método del árbol:Aquí encontramos una nueva instrucción, la cual es visitar, puede realizar la operación que el usuario desee.3.4.2. Recorrido en PreordenSe visita primero el nodo actual, luego el izquierdo y finalmente el derechoÉste recorrido es muy importante, ya que también existe una versión suya en grafos, la cual es llamada búsqueda en profundidad, y su variante es llamada backtracking, con la cual se pueden solucionar la mayor parte de los problemas que se refieren a buscar una permutación.FlashLinux - 2009 Página | 26


3.4.3. Recorrido en PostordenVisita primero los nodos hijos y luego el actual. Es decir; Recorre primero el subárbol izquierdo, luego recorre el subárbol derecho. Para finalmente visitar la raíz.Éste recorrido es útil cuando se necesitan ir borrando los nodos que se visitan, ya que garantiza que nunca quedarán “nodos sueltos”.OBSERVACIÓN: 2

Existe un método "mecánico" para listar los nodos de un árbol en cada uno de los recorridos descritos. Es el siguiente:

Empezando por la raíz, y avanzando en sentido contrario a las agujas de un reloj, trazar una trayectoria que se mantenga lo más cerca posible del árbol.

Entonces:• En Preorden un nodo se lista la primera vez que se pasa por él.• El Inorden, una hoja se lista la primera vez que se pasa por ella y un nodo interior se lista la segunda vez que se pasa por él.• En Postorden, un nodo se lista la última vez que se pasa por él.

Figura 3.8

Hasta aquí toda la teoría, ahora veamos la implementación en JAVA.2 Tomado de: Estructura de datos en java – Abraham Gamarra MorenoFlashLinux - 2009 Página | 27


2.4. IMPLEMENTACIÓNAhora implementaremos la clase NodoArbol, la clase arbol y sus principales operaciones que realiza. Como en todos los casos, nuestro arbol alamcenará numeros enteros.EJEMPLO 01:

Implementación de la clase NodoArbol:public class NodoArbol {//para el tipo de dato que va a almacenar el arbol, en este caso almacenará numeros enteros. int nombre;//apuntadores para el subarbol izquierda y derecha. NodoArbol izquierda = null; NodoArbol derecha = null; public NodoArbol(int nombre) { this.nombre = nombre; izquierda = null; derecha = null; }//método que nos permite crear un nuevo elemento e insertarlo en el arbol public void insertar_elemento(int nombre) { if (nombre < this.nombre) { if (izquierda == null) { izquierda = new NodoArbol(nombre); } else { izquierda.insertar_elemento(nombre); } } if (nombre > this.nombre) { if (derecha == null) { derecha = new NodoArbol(nombre); } else { derecha.insertar_elemento(nombre); } } }}



Implementación de la clase arbol:public class arbol { NodoArbol raiz; public arbol() { raiz = null; } public void InsertarNodo(int nombre) { if (raiz == null) { raiz = new NodoArbol(nombre); } else { raiz.insertar_elemento(nombre); } } public String preorden() { String resultado = preorden(raiz); return resultado; } public String in_orden() { String resultado = inorden(raiz); return resultado; } public String post_orden() { String resultado = postorden(raiz); return resultado; } //Recorrido en preOrdenpublic String preorden(NodoArbol nodo) { String cadena = new String(); if (nodo != null) { cadena += " " + String.valueOf(nodo.nombre); cadena += preorden(nodo.izquierda); cadena += preorden(nodo.derecha); } else { cadena = ""; } return cadena; } //Recorrido en InOrden public String inorden(NodoArbol nodo) { String cadena = new String(); if (nodo != null) { cadena += preorden(nodo.izquierda); cadena += " " + String.valueOf(nodo.nombre);FlashLinux - 2009 Página | 29

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas cadena += preorden(nodo.derecha); } else { cadena = ""; } return cadena; } //Recorrido en PostOrden public String postorden(NodoArbol nodo) { String cadena = new String(); if (nodo != null) { cadena += preorden(nodo.izquierda); cadena += preorden(nodo.derecha); cadena += " " + String.valueOf(nodo.nombre); } else { cadena = ""; } return cadena; }}Implementación de la clase Prueba_NodoArbol: Utiliza la clase arbol.import javax.swing.JOptionPane;public class prueba_NodoArbol { public static void main(String args[]){ //Creamos un nuevo arbol, llamado “a”. arbol a=new arbol(); // Insertamos los Nodos en el arbol “a” a.InsertarNodo(5); a.InsertarNodo(0); a.InsertarNodo(12); a.InsertarNodo(3); //Mostramos las diferentes formas de recorrer un arbol y los imprimimos en pantalla JOptionPane.showMessageDialog(null,"\n"+a.preorden()); JOptionPane.showMessageDialog(null,"\n"+a.in_orden()); JOptionPane.showMessageDialog(null,"\n"+a.post_orden()); }}



EJEMPLO DE PROGRAMAS: PILAS

¡ IMPORTANTE !: En en capitulo I observamos la implementacion en codigo java sobre PILAS; pues bien, ya sabemos las operaciones básicas que realiza.Si ya sabemos las operaciones básicas que realiza una pila y esto a su vez ya está implementado, en los ejemplos posteriores que vamos a realizar solo me centraré en implementar los métodos que son necesarios para solucionar determinados ejercicios.Que lindo...!, Pero deseo que me lo expliques mejor.Los métodos tales como apilar, desapilar, cima, contenido, etc, que son propios de la clase pila, no los modificaré en absoluto; A continuacion se puede observar la clase apilar tal como está implementado en el capitulo I: public void apilar(int nombre) {// creamos un Nodo temporal para almacenar el valor que vamos a insertar. Nodo temp = new Nodo(); temp.nombre = nombre; if (inicio == null) { fin = inicio; } temp.sgte = inicio; inicio = temp; }


CAPITULO IV:

EJEMPLOS


Todo el código anterior lo reemplazaré por el siguiente, y practicamente será lo mismo. Si en caso sea necesario su modificación, lo mencionaré y realizaré los cambios necesarios.public void apilar(...){ // método apilar, implementado... }

Ejemplo 01:Se tiene una pila que almacena nombres de unos amigos, se pide implementar un método que invierta el contenido de esta pila.SOLUCION:

Implementacion de la clase pila:import javax.swing.JOptionPane;public class pila { // creacion de la clase Nodo. class Nodo { String nombre; // cadena de texto que almacena los nombres. Nodo sgte; } Nodo inicio = null; Nodo fin = null;public void apilar(String nombre) { // método apilar, implementado... }public void desapilar() { // método desapilar, implementado... }public String cima() { if (inicio == null) { // si la pila esta vacía retornar “” return (""); } else { // si la pila no se encuentra vacia, retornar el valor de la cima. return inicio.nombre; } }FlashLinux - 2009 Página | 32

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas//Implementacion del metodo contenido, que nos permite visualizar el contenidode la pila. public void contenido() { Nodo temp = inicio; String cad = "La lista de nombres es: "; while (temp != null) { cad += "\n- " + temp.nombre; temp = temp.sgte; } JOptionPane.showMessageDialog(null, cad); } public void invertirPila(){ Nodo temp = inicio; // creamos una pila temporal para almacenar la pila invertida... pila pilaInvertida = new pila(); while(temp!=null){ pilaInvertida.apilar(temp.nombre); temp=temp.sgte; } pilaInvertida.contenido(); }}Implementacion de la clase pruebaInvertir:

import javax.swing.JOptionPane;public class PruebaInvertir { public static void main(String[ ] args) { pila p = new pila(); String nombre; //Ingresamos los valores a la pila mediante el metodo apilar. for (int i = 1; i <= 4; i++) { nombre = JOptionPane.showInputDialog("Ingrese nombre: "); p.apilar(nombre); } //Mostramos el contenido de la pila. p.contenido(); //La pila invertida es: p.invertirPila(); }}FlashLinux - 2009 Página | 33


Ejemplo 02:Se tiene una pila que almacena numeros enteros positivos, se pide eliminar los "n" primeros elementos que fueron ingresados. Es decir, si los elementos ingresados fueron: 12, 8, 14, 9, 6, 5. cuando: n=3, (sabemos que los numero 5, 6 y 9 son los primeros elementos ingresados). Entonces el contenido de la pila será: 12, 8, 14

SOLUCION:

Implementación de la clase pila:import javax.swing.JOptionPane;public class pila { // creacion de la clase Nodo. class Nodo { int nombre; // para el valor que va almacenar Nodo sgte; } Nodo inicio = null; Nodo fin = null; public void apilar(int x) { // método apilar, implementado... } public void desapilar() { // método desapilar, implementado... } public int cima() { // método cima, implementado... } //Implementacion del metodo contenido, que nos permite visualizar el contenido de la pila. public void contenido() { Nodo temp = inicio; String cad = "El contenido de la pila es:"; while (temp != null) { cad += "\n ==> " + temp.nombre; temp = temp.sgte; } JOptionPane.showMessageDialog(null, cad); } FlashLinux - 2009 Página | 34


public void eliminar(int n) { Nodo temp = inicio; pila tempPila = new pila(); // para almacenar el numero de elementos que contiene la pila. int cantidad = 0; while (temp != null) { tempPila.apilar(temp.nombre); // apila los elementos en tempPila... desapilar(); cantidad++; temp = temp.sgte; } for (int i = 1; i <= cantidad; i++) { if (i <= n) { tempPila.desapilar(); } else { apilar(tempPila.cima()); tempPila.desapilar(); } } }}Implementación de la clase PruebaEliminar:

import javax.swing.JOptionPane;public class PruebaEliminar{ public static void main(String[] args) { pila p = new pila(); int nombre;int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos elementos desea almacenar en la pila?: ")); //Ingresamos los valores a la pila mediante el metodo apilar. for (int i = 1; i <= cant; i++) { nombre = Integer.parseInt(JOptionPane.showInputDialog("Ingrese valor a apilar: ")); p.apilar(nombre); }FlashLinux - 2009 Página | 35

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas //Mostramos el contenido de la pila. p.contenido(); //método que elimina los n primeros numeros ingresados..int n = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos numeros deseas eliminar?: "));p.eliminar(n);//Despues de eliminar los n primeros valores ingresados, mostramos el nuevo contenido de la pila. p.contenido(); }}



Ejemplo 03:Se tiene un polinomio de la forma: f(x) = ax b + c, Los valores de los coefecientes y exponentes se almacenan en una pila. se pide implementar un método que halle la derivada de f(x).

SOLUCIÓN:

Implementación de la clase pila:import javax.swing.JOptionPane;public class pila { // creacion de la clase Nodo. class Nodo { int coefeciente; // para almacenar el coefeciente del polinomio int exponente; // para almacenar el exponente del polinomio Nodo sgte; } Nodo inicio = null; Nodo fin = null;//Implementacion del metodo apilar que nos permite insertar un elemento en la pila, en este caso como se trata de una pila insertamos en el inicio o cima de la pila. public void apilar(int coef, int expo) { // creamos un Nodo temporal para almacenar el valor que vamos a insertar. Nodo temp = new Nodo(); temp.coefeciente = coef; temp.exponente = expo; if (inicio == null) { fin = inicio; } temp.sgte = inicio; inicio = temp; } public void desapilar() { // método desapilar, implementado... } public int cima_coefeciente() { if (inicio == null) { // si la pila esta vacía return (-100); } else { // si la pila no se encuentra vacia, retornar el valor de la cima. return inicio.coefeciente; } }FlashLinux - 2009 Página | 37

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas public int cima_exponente() { if (inicio == null) { // si la pila esta vacía return (-100); } else { // si la pila no se encuentra vacia, retornar el valor de la cima. return inicio.exponente; } }//Implementacion del metodo contenido, que nos permite visualizar el contenido de la pila. public void contenido() { Nodo temp = inicio; String cad = "El polinomio es:\n"; while (temp != null) { cad += temp.coefeciente + " X^" + temp.exponente + " + "; temp = temp.sgte; } JOptionPane.showMessageDialog(null, cad); } // Implementacion del metodo derivar... public void derivar() { Nodo temp = inicio; // creamos un nuevo apuntador... // creamos una pila temporal para almacenar los valores del polinomio derivada pila tempPila = new pila(); while (temp != null) { tempPila.apilar(temp.coefeciente * temp.exponente, temp.exponente - 1); desapilar(); temp = temp.sgte; } // almacenamos en la pila actual los valores que ya hemos derivado...while (tempPila.cima_coefeciente() != -100) { //apilamos los valores del coefeciente y el exponente en la pila actual, al mismo tiempo que vamos desapilando.. apilar(tempPila.cima_coefeciente(), tempPila.cima_exponente()); tempPila.desapilar(); } }}



Implementación de la clase pruebaDerivada:import javax.swing.JOptionPane;public class PruebaDerivada { public static void main(String[ ] args) { pila p = new pila(); int exponente = 0; int coefeciente = 0;int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos valores desea almacenar en la pila?: ")); //Ingresamos los valores a la pila mediante el metodo apilar. for (int i = 1; i <= cant; i++) { coefeciente = Integer.parseInt(JOptionPane.showInputDialog("Ingrese coefeciente: ")); exponente = Integer.parseInt(JOptionPane.showInputDialog("Ingrese exponente: ")); p.apilar(coefeciente, exponente); } //Mostramos el contenido de la pila. p.contenido(); // Hacemos uso del metodo "derivar".. p.derivar();//Mostramos el nuevo contenido del polinomio, pero ahora ya esta derivado...contenido(); }}



Ejemplo 04:Se tiene un polinomio de la forma: f(x) = ax b + c, Los valores de los coefecientes y exponentes se almacenan en una pila. se pide implementar un método que halle la integral de f(x).

SOLUCIÓN:

Implementación de la clase pila:

import javax.swing.JOptionPane;public class pila { // creacion de la clase Nodo. class Nodo { double coefeciente; // para almacenar el coefeciente del polinomio double exponente; // para almacenar el exponente del polinomio Nodo sgte; } Nodo inicio = null; Nodo fin = null; //Implementacion del metodo apilar que nos permite insertar un elemento en la pila, en este caso como se trata de una pila insertamos en el inicio o cima de la pila. public void apilar(double coef, double expo) { // creamos un Nodo temporal para almacenar el valor que vamos a insertar. Nodo temp = new Nodo(); temp.coefeciente = coef; temp.exponente = expo; if (inicio == null) { fin = inicio; } temp.sgte = inicio; inicio = temp; } public void desapilar() { // método desapilar, implementado... } public double cima_coefeciente() { if (inicio == null) { // si la pila esta vacía return (-100); } else { // si la pila no se encuentra vacia, retornar el valor de la cima. return inicio.coefeciente; } }FlashLinux - 2009 Página | 40


public double cima_exponente() { if (inicio == null) { // si la pila esta vacía return (-100); } else { // si la pila no se encuentra vacia, retornar el valor de la cima. return inicio.exponente; } } //Implementacion del metodo contenido, que nos permite visualizar el contenido de la pila. public void contenido() { Nodo temp = inicio; String cad = "El polinomio es:\n"; while (temp != null) { cad += temp.coefeciente + " X^" + temp.exponente + " + "; temp = temp.sgte; } JOptionPane.showMessageDialog(null, cad); } // Implementacion del metodo integrar... public void integrar() { Nodo temp = inicio; // creamos un nuevo apuntador... // creamos una pila temporal para almacenar los valores del polinomio integrado pila tempPila = new pila(); while (temp != null) { tempPila.apilar(temp.coefeciente / (temp.exponente + 1), temp.exponente + 1); desapilar(); temp = temp.sgte; } // almacenamos en la pila actual los valores que ya hemos integrado... while (tempPila.cima_coefeciente() != -100) { //apilamos los valores del coefeciente y el exponente en la pila actual, al mismo tiempo que vamos desapilando.. apilar(tempPila.cima_coefeciente(), tempPila.cima_exponente()); tempPila.desapilar(); } }}



Implementarción de la clase PruebaIntegral:import javax.swing.JOptionPane;public class PruebaIntegral { public static void main(String[] args) { pila p = new pila(); double exponente = 0; double coefeciente = 0;int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos valores desea almacenar en la pila?: ")); //Ingresamos los valores a la pila mediante el metodo apilar. for (int i = 1; i <= cant; i++) { coefeciente = Integer.parseInt(JOptionPane.showInputDialog("Ingrese coefeciente: ")); exponente = Integer.parseInt(JOptionPane.showInputDialog("Ingrese exponente: ")); p.apilar(coefeciente, exponente); } //Mostramos el contenido de la pila. p.contenido(); // Hacemos uso del metodo "integrar".. p.integrar();//Mostramos el nuevo contenido del polinomio, pero ahora ya esta integradocontenido(); }}



Ejemplo 05:Se tiene una pila que almacena n valores enteros positivos. Se pide implementar un método para reemplazar un elemento de la pila por un nuevo valor; ambos numeros deben ser ingresados por teclado. (Tomado de: Estructura de datos en java – MG. Abraham Gamarra Moreno)Ejemplo: Si x = 7 ^ y = 12.

SOLUCIÓN:

Implementación de la clase pila:import javax.swing.JOptionPane;public class pila { // creacion de la clase Nodo. class Nodo { int nombre; // para el valor que va almacenar Nodo sgte; } Nodo inicio = null; Nodo fin = null;public void apilar(int x) { // metodo apilar, implementado... }public void desapilar() { // metodo desapilar, implementado... }public int cima() { // metodo cima, implementado... } public void contenido() { // metodo contenido, implementado... } FlashLinux - 2009 Página | 43

4

18

7

15

4

18

12

15

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas//Implementacion del metodo reemplazar, que reemplaza el valor de x por y. public void reemplazar(int x, int y) { Nodo temp = inicio; pila tempPila = new pila(); //apila los valores a tempPila while (temp != null) { tempPila.apilar(temp.nombre); desapilar(); temp = temp.sgte; } //Devuelve los elementos de tempPila, pero reemplazando x por el valor de y. while (tempPila.cima() != -1) { if (tempPila.cima() == x) { apilar(y); } else { apilar(tempPila.cima()); } tempPila.desapilar(); } }}Implementación de la clase PruebaReemplazar:import javax.swing.JOptionPane;public class PruebaReemplazar { public static void main(String[] args) { pila p = new pila(); int nombre; int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos valores desea almacenar en la pila?: ")); //Ingresamos los valores a la pila mediante el metodo apilar. for (int i = 1; i <= cant; i++) { nombre = Integer.parseInt(JOptionPane.showInputDialog("Ingrese " + i + "º valor a apilar: ")); p.apilar(nombre); } //Mostramos el contenido de la pila. p.contenido(); int x = Integer.parseInt(JOptionPane.showInputDialog("¿Que numero desea reemplazar?: "));FlashLinux - 2009 Página | 44


int y = Integer.parseInt(JOptionPane.showInputDialog("¿Por que valor desea reemplazarlo?: ")); //realizamos el reemplazo del valor de x por el nuevo valor que es y p.reemplazar(x, y); //Despues de realizar el reemplazo, mostramos el nuevo contenido de la pila p.contenido(); }}



Ejemplo 06:Decimos que una frase o un numero es capicúa si se lee igual de izquierda a derecha que de derecha a izquierda desdeñando los espacios en blanco que haya. Por ejemplo, la frase: "dabale arroz a la zorra el abad" (de dudosas consecuencias) es capicúa. Se pide implementar un metodo, haciendo uso de pilas, para evaluar si un numero o una frase en capicua.SOLUCIÓN:

Implementación de la clase pila:import javax.swing.JOptionPane;public class pila { // creacion de un Nodo. class Nodo { char nombre; Nodo sgte; } Nodo inicio = null; Nodo fin = null;//Implementacion del metodo apilar que nos permite insertar un elemento en la pila, en este caso apilamos un caracter. public void apilar(char x) { // creamos un Nodo temporal para almacenar el valor que vamos a insertar. Nodo temp = new Nodo(); temp.nombre = x; if (inicio == null) { fin = inicio; } temp.sgte = inicio; inicio = temp; } public void desapilar() { //metodo desapilar, implementado... } public char cima() { if (inicio != null) {// si la pila no se encuentra vacia retornar el ultimo caracter de la pila. return inicio.nombre; } else { // si esta vacia devolver '#' return '#'; } }


“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas //implementacion del metodo evalua_expresion. public void capicua(String expresion) { pila tempPila = new pila(); pila tempPila2 = new pila(); int i = 0; boolean validame = true; char caracter = '\0';//apilamos los valores, al mismo tiempo que vamos apilando a tempPila para luego comparar. while (expresion.length() > i && validame == true) { caracter = expresion.charAt(i); //chartAt(i): toma un caracter de la cadena en la posicion "i". //solo apilamos si el caracter no es el vacio... if (caracter != ' ') { //apilamos en las dos pilas, al mismo tiempo... apilar(caracter); tempPila.apilar(caracter); } i++; } //apilamos los caracteres en tempPila2, sabemos que se apilaran en forma inversa que la pila actual.. while (cima() != '#') { tempPila2.apilar(cima()); desapilar(); }//Una vez que ya tenemos tempPila y tempPila2, este ultimo inversa al primero, procedemos a comparar. while (tempPila.cima() != '#') { if (tempPila.cima() == tempPila2.cima()) { validame = true; tempPila.desapilar(); tempPila2.desapilar(); } else { validame = false; break; } } //comprobar validame... y mostrar el mensaje. if (validame == true) { JOptionPane.showMessageDialog(null, "La expresion ingresado SI es capícua...");


“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas } else { JOptionPane.showMessageDialog(null, "La expresion ingresado NO es capícua... "); } }}Implementación de la clase PruebaCapicua:import javax.swing.JOptionPane;public class PruebaCapicua { public static void main(String[] args) { pila p = new pila(); //Ingrese expresion String nombre = JOptionPane.showInputDialog("Ingrese un numero o una palabra: "); //Utilizacion del metodo capicua, para evaluar si al expresion ingresada es un capicua o no. p.capicua(nombre); }}



Ejemplo 07:Programa que valida un expresion matematica mediante la utilizacion de PILAS, el programa te permite ingresar una expresion matematica cualquiera, por ejemplo: si ingresamos {(2+8) -[5*8]},puede ser validado como vedadero o faso. (Tomado de: Estructura de datos en java – MG. Abraham Gamarra Moreno)SOLUCIÓN:

Implementación de la clase pila:import javax.swing.JOptionPane;public class pila { // creacion de un Nodo. class Nodo { char nombre; Nodo sgte; } Nodo inicio = null; Nodo fin = null; public void anula() { inicio = fin = null; }//Implementacion del metodo apilar que nos permite insertar un elemento en la pila, en este caso como se trata de una pila insertamos en el inicio o cima de la pila. public void apilar(char x) { // creamos un Nodo temporal para almacenar el valor que vamos a insertar. Nodo temp = new Nodo(); temp.nombre = x; if (inicio == null) { fin = inicio; } temp.sgte = inicio; inicio = temp; } public void desapilar() { // metodo desapilar, implementado... } public char cima() { if (inicio != null) { // si la pila no se encuentra vacia retornar el ultimo caracter de la pila.FlashLinux - 2009 Página | 49

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas return inicio.nombre; } else { // si esta vacia devolver '#' return '#'; } } //implementacion del metodo evalua_expresion. public void evalua_expresion(String expresion) { int i = 0; boolean validame = true; char caracter, caracter1, caracter2; //caracteres para parentesis, llaves,corchetes, etc... anula(); // Limpia toda la pila caracter = caracter1 = caracter2 = '\0'; while (expresion.length() > i && validame == true) { caracter = expresion.charAt(i); //chartAt(i): toma un caracter de la cadena en la posicion "i". if (caracter == '(' || caracter == '[' || caracter == '{') { // si el caracter es '(', '[' o '{' utilizamos el metodo apila para insertar el elemento en la PILA. apilar(caracter); } if (caracter == ')' || caracter == ']' || caracter == '}') { if (inicio == null) { validame = false; } else { switch (caracter) { case ')': caracter1 = '('; break; case ']': caracter1 = '['; break; case '}': caracter1 = '{'; break; } // caracter2 toma el ultimo valor de la Pila... caracter2 = cima(); desapilar(); // desapilamos la cima, es decir lo quitamos de la pila. if (caracter1 != caracter2) { validame = false; } } } i++; }FlashLinux - 2009 Página | 50


// Si al final te queda algun caracter, ya sea un parentesis, un corchete o una llave, eso quiere decir que la expresion no es válida. if (inicio != null) { validame = false; } //validame es igual que decir: validame=true if (validame == true) { JOptionPane.showMessageDialog(null, "La expresion es valida. "); } else { JOptionPane.showMessageDialog(null, "La expresion no es valida. "); } }}Implementación de la clase EvaluaExpresion:import javax.swing.JOptionPane;public class EvaluaExpresion { public static void main(String[] args) { pila p = new pila(); //Ingresamos la expresion a evaluar... String nombre = JOptionPane.showInputDialog("Ingrese expresión: "); //Utilizacion del metodo evalua_expresion. p.evalua_expresion(nombre); }}



EJEMPLO DE PROGRAMAS: COLAS

Ejemplo 08:Bueno acá les dejo un programita para calentar, es sencillo y hace uso de colas.Se tiene una cola que almacena numeros enteros positivos, relizar un metodo que nos muestre el doble de los números almacenados en dicha cola.SOLUCIÓN:

Implementación de la clase Cola:import javax.swing.JOptionPane;public class Cola { //Creacion de la clase Nodo class Nodo { int nombre; Nodo sgte; } Nodo inicio = null; Nodo fin = null; public void encolar(int x) { //metodo encolar, implementado... } public void desencolar() { //metodo desencolar, implementado... } public int frente() { //metodo frente, implementado... } public void contenido() { //metodo contenido, implementado... } public void Doble() { //creamos una nueva Cola para almacenar los numeros duplicados... Cola tempCola = new Cola(); //almacenamos los elementos en tempCola... while (frente() != -1) { tempCola.encolar(frente()); desencolar(); }FlashLinux - 2009 Página | 52


//encolamos en la cola actual los valores de tempCola, pero multiplicado por 2.. while (tempCola.frente() != -1) { encolar(2 * tempCola.frente()); tempCola.desencolar(); } }}Implementación de la clase PruebaDoble:import javax.swing.JOptionPane;public class PruebaDoble { public static void main(String[] args) { Cola c = new Cola();//Declaramos las variables que va a almacenar la cola, en este caso almacenará numeros enteros. int n; //Ingresamos los valores a la cola mediante el metodo encolar. int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos elementos desea almacenar en la cola?: ")); for (int i = 1; i <= cant; i++) { n = Integer.parseInt(JOptionPane.showInputDialog("Ingrese " + i + "º valor a encolar: ")); //encolamos el valor de n c.encolar(n); } //mostramos el contenido de la cola... c.contenido(); //utilizamos el metodo Doble... c.Doble(); //mostramos el nuevo contenido de la cola, pero esta vez nos mostrará el doble de los numeros... c.contenido(); }}



Ejemplo 09:Se tiene una cola que almacena numeros enteros positivos, se pide implementar un método que nos pemita obtener el menor de los numeros almacenados en la cola.SOLUCIÓN:

Implementación de la clase Cola:import javax.swing.JOptionPane;public class Cola { //Creacion de la clase Nodo class Nodo { int nombre; Nodo sgte; } Nodo inicio = null; Nodo fin = null; //metodo que inserta un elemento al final de la cola. public void encolar(int x) { //metodo encolar, implementado... } //metodo que elimina el valor que esta al frente. public void desencolar() { //metodo desencolar, implementado... } // metodo que retorna el valor de la cola del frente. public int frente() { //metodo frente, implementado... } //muestra el contenido de la cola public void contenido() { //metodo contenido, implementado... }//metodo para calcular el menor de los numeros.. public int calcularMenor() { Cola tempCola = new Cola(); int temp; //encolamos los elementos en una cola temporal... while (frente() != -1) { tempCola.encolar(frente()); desencolar(); }FlashLinux - 2009 Página | 54


//obtenemos el menor de los numeros de tempCola, al mismo tiempo que vamos devolviendo los elementos de la cola temporal... temp = tempCola.frente(); while (tempCola.frente() != -1) { if (tempCola.frente() < temp) { temp = tempCola.frente(); } encolar(tempCola.frente()); tempCola.desencolar(); } return temp; }}Implementación de la clase PruebaMenor:

import javax.swing.JOptionPane;public class PruebaMenor { public static void main(String[] args) { Cola c = new Cola(); //Declaramos las variables que va a almacenar la cola, en este caso almacenará numeros enteros. int n; //Ingresamos los valores a la cola mediante el metodo encolar. int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos elementos desea almacenar en la cola?: ")); for (int i = 1; i <= cant; i++) { n = Integer.parseInt(JOptionPane.showInputDialog("Ingrese " + i + "º valor a encolar: ")); c.encolar(n); } //Mostramos el contenido de la cola. c.contenido(); //Obtener el menor valor de la cola... JOptionPane.showMessageDialog(null, "El menor valor de la cola es: " + c.calcularMenor()); }}



Ejemplo 10:Se tiene una cola que almacena numeros enteros positivos, utilizando el método creado en el ejemplo anterior(método que nos permite obtener el numero menor), implementar un metodo que nos permite ordenar los elementos de la cola de menor a mayor.SOLUCIÓN:

Implementación de la clase Cola:import javax.swing.JOptionPane;public class Cola { //Creacion de la clase Nodo class Nodo { int nombre; Nodo sgte; } Nodo inicio = null; Nodo fin = null; //metodo que inserta un elemento al final de la cola. public void encolar(int x) { //metodo encolar, implementado... } //metodo que elimina el valor que esta al frente. public void desencolar() { //metodo desencolar, implementado... } // metodo que retorna el valor de la cola del frente. public int frente() { //metodo frente, implementado... } //muestra el contenido de la cola public void contenido() { //metodo contenido, implementado... } //metodo para calcular el menor de los numeros.. public int calcularMenor() { Cola tempCola = new Cola(); int temp; //encolamos los elementos en una cola temporal... while (frente() != -1) {FlashLinux - 2009 Página | 56

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas tempCola.encolar(frente()); desencolar(); }//obtenemos el menor de los numeros de tempCola, al mismo tiempo que vamos devolviendo los elementos de la cola temporal... temp = tempCola.frente(); while (tempCola.frente() != -1) { if (tempCola.frente() < temp) { temp = tempCola.frente(); } encolar(tempCola.frente()); tempCola.desencolar(); } return temp; }//metodo que nos permite ordenar la cola en forma ascendente public void OrdenarCola() { Cola tempCola = new Cola(); int menor; //almacenamos los valores de la cola en una nueva cola temporal... while (frente() != -1) { tempCola.encolar(frente()); desencolar(); } while (tempCola.frente() != -1) { //obtenemos el menor valor de la cola temporal... menor=tempCola.calcularMenor(); // si el numero es igual al menor numero de la cola temporal, entonces encolamos en la cola actual if (tempCola.frente() == menor) { encolar(tempCola.frente()); } else {// de lo contrario encolamos en la misma cola temporal, sabemos que va ir desde el frente hasta el final de la cola temporal.... tempCola.encolar(tempCola.frente()); } //desencolamos... tempCola.desencolar(); } }}



Implementación de la clase PruebaOrdenar:import javax.swing.JOptionPane;public class PruebaOrdenar { public static void main(String[] args) { Cola c = new Cola();//Declaramos las variables que va a almacenar la cola, en este caso almacenará numeros enteros. int n;//Ingresamos los valores a la cola mediante el metodo encolar. int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos elementos desea almacenar en la cola?: ")); for (int i = 1; i <= cant; i++) { n = Integer.parseInt(JOptionPane.showInputDialog("Ingrese " + i + "º valor a encolar: ")); c.encolar(n); } //Mostramos el contenido de la cola. c.contenido(); //utilizamos el metodo ordenarCola para poder ordenar los numeros ascendentemente c.OrdenarCola();//mostramos el nuevo contenido de la cola, pero esta vez nos mostrará ordenado... c.contenido(); }}



Ejemplo 11:Se tiene una cola que almacena enteros positivos y negativos. Se pide implementar una función que utilice esta cola y almacene los positivos en una pila y los negativos en otra pila. Luego desde las pilas desapile los elementos y almacene los elementos en otras dos colas. (Tomado de: Estructura de datos en java – MG. Abraham Gamarra Moreno)En este ejemplo solo implementarémos los codigos en la clase PruebaPosiNega.SOLUCIÓN:

Implementación de la clase Pila:import javax.swing.JOptionPane;public class pila { // creacion de la clase Nodo. class Nodo { int nombre; // para el valor que va almacenar Nodo sgte; } Nodo inicio = null; Nodo fin = null;public void apilar(int x) { // metodo apilar, implementado.... }public void desapilar() { // metodo desapilar, implementado.... } //retorna el valor de la cima como un numero entero. public int cima() { if (inicio == null) { // si la pila esta vacía return (-1000); } else { // si la pila no se encuentra vacia, retornar el valor de la cima. return inicio.nombre; } } public void contenido() { // metodo contenido, implementado....}



Implementación de la clase Cola:import javax.swing.JOptionPane;public class Cola { //Creacion de la clase Nodo class Nodo { int nombre; Nodo sgte; } Nodo inicio = null; Nodo fin = null; //metodo que inserta un elemento al final de la cola. public void encolar(int x) { //metodo encolar, implementado... } //metodo que elimina el valor que esta al frente. public void desencolar() { //metodo desencolar, implementado... } // metodo que retorna el valor de la cola del frente. public int frente() { if (inicio == null) { // si la cola es vacía retorna -1000 return (-1000); } else { // retorna el valor que esta al frente... return inicio.nombre; } } public void contenido() { // metodo contenido, implementado....}Implementación de la clase PruebaPosiNega:import javax.swing.JOptionPane;public class PruebaPosiNega { public static void main(String[] args) { Cola c = new Cola(); pila Pila_positivos = new pila(); pila Pila_negativos = new pila(); Cola Cola_positivos = new Cola();FlashLinux - 2009 Página | 60

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas Cola Cola_negativos = new Cola();//Declaramos las variables que va a almacenar la cola, en este caso almacenará numeros enteros. int n; //Ingresamos los valores a la cola mediante el metodo encolar. int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos elementos desea almacenar en la cola?: ")); for (int i = 1; i <= cant; i++) { n = Integer.parseInt(JOptionPane.showInputDialog("Ingrese " + i + "º valor a encolar: ")); //encolamos el valor de n c.encolar(n); } //mostramos el contenido de la cola... c.contenido(); //apilamos los numeros de la cola a las pilas... while (c.frente() != -1000) { if (c.frente() >= 0) { Pila_positivos.apilar(c.frente()); } else { Pila_negativos.apilar(c.frente()); } c.desencolar(); } //mostramos los contenidos de las pilas... Pila_positivos.contenido(); Pila_negativos.contenido(); //Llevamos los valores de la pila a la cola... //PARA LA PILA POSITIVO while (Pila_positivos.cima() != -1000) { Cola_positivos.encolar(Pila_positivos.cima()); Pila_positivos.desapilar(); } //PARA LA PILA NEGATIVO while (Pila_negativos.cima() != -1000) { Cola_negativos.encolar(Pila_negativos.cima()); Pila_negativos.desapilar(); } //mostramos los contenidos de las colas... Cola_positivos.contenido(); Cola_negativos.contenido(); }}FlashLinux - 2009 Página | 61


Ejemplo 12:Los datos de los competidores de una carrera automovilistica son almacenados en una cola, asi como tambien el resultado final de la carrera, los datos que se almacenan son: el nombre del piloto, y el tiempo de recorrido (en minutos). Se pide implementar una función que calcule el promedio de tiempo de carrera. Además de ello modificar la cola para que nos muestre los nombres de los pilotos y la diferencia de tiempo (estos deben quedar ordenamos de acuerdo a la diferencia de tiempo con el menor tiempo de recorrido).SOLUCIÓN:

Implementación de la clase Cola:import javax.swing.JOptionPane;public class Cola { //Creacion de la clase Nodo class Nodo { String piloto; double tiempo; Nodo sgte; } Nodo inicio = null; Nodo fin = null; //metodo que inserta un elemento al final de la cola. public void encolar(int x) { //metodo encolar, implementado... } //metodo que elimina el valor que esta al frente. public void desencolar() { //metodo desencolar, implementado... } // metodo que retorna el valor de la cola del frente: piloto. public String frente_piloto() { if (inicio == null) { // si la cola es vacía retorna -1 return (""); } else { // retorna el valor que esta al frente... return inicio.piloto; } } // metodo que retorna el valor de la cola del frente: tiempo. public double frente_tiempo() { if (inicio == null) { // si la cola es vacía retorna -1 return (-1);FlashLinux - 2009 Página | 62


} else { // retorna el valor que esta al frente... return inicio.tiempo; } } //muestra el contenido de la cola public void contenido() { Nodo temp = inicio; String cad = "Impresión de la cola:\n"; while (temp != null) { cad += temp.piloto + " // " + temp.tiempo + " ==> "; temp = temp.sgte; } JOptionPane.showMessageDialog(null, cad); } //metodo para calcular el menor de los numeros.. public double calcularMenor() { Cola tempCola = new Cola(); double temp; //encolamos los elementos en una cola temporal... while (frente_tiempo() != -1) { tempCola.encolar(frente_piloto(), frente_tiempo()); desencolar(); }//obtenemos el menor de los numeros de tempCola, al mismo tiempo que vamos devolviendo los elementos de la cola temporal... temp = tempCola.frente_tiempo(); while (tempCola.frente_tiempo() != -1) { if (tempCola.frente_tiempo() < temp) { temp = tempCola.frente_tiempo(); } encolar(tempCola.frente_piloto(), tempCola.frente_tiempo()); tempCola.desencolar(); } return temp; } //metodo que calcular el promedio de tiempo... public double promedio() { Cola tempCola = new Cola(); double acumulador = 0; //para acumular el tiempo double cantidad = 0;//para obtener la contidad de elementos que contiene la cola...FlashLinux - 2009 Página | 63

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas //encolamos los elementos en una cola temporal... while (frente_tiempo() != -1) { tempCola.encolar(frente_piloto(), frente_tiempo()); desencolar(); }//obtenemos el menor de los numeros de tempCola, al mismo tiempo que vamos devolviendo los elementos de la cola temporal... while (tempCola.frente_tiempo() != -1) { encolar(tempCola.frente_piloto(), tempCola.frente_tiempo());//sumamos el tiempo, ademas agregamos el contador para obtener la cantidad de elementos de la cola... acumulador += tempCola.frente_tiempo(); cantidad++; tempCola.desencolar(); } return acumulador / cantidad; }//metodo que nos permite almacenar en una nueva cola los pilotos y la diferencia de tiempo.. public void OrdenarDT() { Cola tempCola = new Cola(); double tm = calcularMenor(); //menor tiempo double temp; //almacenamos los valores de la cola en una nueva cola temporal... while (frente_tiempo() != -1) { tempCola.encolar(frente_piloto(), frente_tiempo() - tm); desencolar(); } while (tempCola.frente_tiempo() != -1) { //obtenemos el menor tiempo de la cola temporal y lo almacenamos en la variable temp temp = tempCola.calcularMenor(); // si el tiempo es igual al menor tiempo de la cola temporal, entonces encolamos en la cola actual... if (tempCola.frente_tiempo() == temp) { encolar(tempCola.frente_piloto(), tempCola.frente_tiempo()); } else {// de lo contrario encolamos en la misma cola temporal, sabemos que va ir desde el frente hasta el final de la cola.... tempCola.encolar(tempCola.frente_piloto(), tempCola.frente_tiempo()); } //desencolamos... tempCola.desencolar(); } }}FlashLinux - 2009 Página | 64


Implementación de la clase PruebaCarrera:import javax.swing.JOptionPane;public class PruebaCarrera { public static void main(String[] args) { Cola c = new Cola();//Declaramos las variables que va a almacenar la cola, en este caso almacenará el nombre del piloto y el tiempo de carrera. String piloto; double tiempo; //Ingresamos los valores a la cola mediante el metodo encolar. int cant = Integer.parseInt(JOptionPane.showInputDialog("¿cuantos elementos desea almacenar en la cola?: ")); for (int i = 1; i <= cant; i++) { piloto = JOptionPane.showInputDialog("Ingrese nombre del " + i + "º piloto a encolar: "); tiempo = Double.parseDouble(JOptionPane.showInputDialog("Ingrese " + i + "º tiempo a encolar: ")); //procedemos a encolar: piloto y tiempo c.encolar(piloto, tiempo); } //Mostramos el contenido de la cola. c.contenido(); //Obtener el menor valor de la cola... JOptionPane.showMessageDialog(null, "El menor valor de la cola es: " + c.calcularMenor()); //Obtener el promedio de la cola... JOptionPane.showMessageDialog(null, "El promedio es: " + c.promedio()); //utilizacion del método que nos permite ordenar de acuerdo a la diferencia de tiempo... c.OrdenarDT(); //mostramos el contenido de la cola, pero esta vez nos mostrará ordenado... c.contenido(); }}



EJEMPLO DE PROGRAMAS: ARBOL

Ejemplo 13:Se tiene un arbol que alamcena numeros enteros, se piede implementar una función que nos permita buscar un numero cualquiera en el arbol. El numero que se desea buscar debe ser ingresado por teclado.SOLUCIÓN:

Implementación de la clase NodoArbol:public class NodoArbol {//para el tipo de dato que va a almacenar el arbol, en este caso almacenará numeros enteros. int nombre;//apuntadores para el subarbol izquierda y derecha. NodoArbol izquierda = null; NodoArbol derecha = null; public NodoArbol(int nombre) { this.nombre = nombre; izquierda = null; derecha = null; }//método que nos permite crear un nuevo elemento e insertarlo en el arbol public void insertar_elemento(int nombre) { if (nombre < this.nombre) { if (izquierda == null) { izquierda = new NodoArbol(nombre); } else { izquierda.insertar_elemento(nombre); } } if (nombre > this.nombre) { if (derecha == null) { derecha = new NodoArbol(nombre); } else { derecha.insertar_elemento(nombre); } } }}FlashLinux - 2009 Página | 66


Implementación de la clase arbol:public class arbol { NodoArbol raiz; public arbol() { raiz = null; } public void insertar_nodo(int nombre) { if (raiz == null) { raiz = new NodoArbol(nombre); } else { raiz.InsertarElemento(nombre); } } //Para mostrar el contenido del arbol utilizaremos el recorrido en preorden. public String preorden() { String resultado = preorden(raiz); return resultado; } public String preorden(NodoArbol nodo) { String cadena = new String(); if (nodo != null) { cadena += " " + String.valueOf(nodo.nombre); cadena += preorden(nodo.izquierda); cadena += preorden(nodo.derecha); } else { cadena = ""; } return cadena; } //Busca un elemento en el arbol public int buscar(int temp) { int x = 0; if (temp < raiz.nombre) { raiz = raiz.izquierda; x = buscar(temp); } if (temp > raiz.nombre) { raiz = raiz.derecha; x = buscar(temp); }FlashLinux - 2009 Página | 67

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas if (temp == raiz.nombre) { x = raiz.nombre; } return x; }}Implementación de la clase prueba_NodoArbol:import javax.swing.JOptionPane;public class prueba_NodoArbol { public static void main(String args[]){ //creamos un nuevo arbol.... arbol a=new arbol(); //Insertamos Nodos en el arbol... a.insertar_nodo(5); a.insertar_nodo(0); a.insertar_nodo(12); a.insertar_nodo(3); //mostramos el contenido del arbol en PreOrden. JOptionPane.showMessageDialog(null, a.preorden()); //Ingresamos el numero que deseamos buscar en el arbol.. int n = Integer.parseInt(JOptionPane.showInputDialog("Ingrese número a buscar: ")); //utilizamos el metodo buscar para poder realizar la busqueda en el arbol. JOptionPane.showMessageDialog(null,"El dato que se busco es: " + a.buscar(n)); }}



Ejemplo 14:La idea de crear un sistema experto proviene de la intención de emular el conocimiento humano. Para ello se intenta introducir en un sistema el conocimiento de un experto humano en un área determinada. Estos sistemas trabajan con inteligencia artificial simbólica, es decir, a nivel de símbolos; como pueden ser ideas, imágenes, conceptos, etc. El sistema experto más sencillo se trata de un árbol de decisiones cuyas hojas finales son el resultado a nuestro problema. En el siguiente gráfico se muestra una estructura en arboles de un sistema experto realmente sencillo, se pide implementar una funcion que nos permita emular este sistema experto haciendo uso de arboles.

SOLUCIÓN:

Implementación de la clase NodoArbol:public class NodoArbol {//para el tipo de dato que va a almacenar el arbol, en este caso almacenará numeros enteros. int nombre;//apuntadores para el subarbol izquierda y derecha. NodoArbol izquierda = null; NodoArbol derecha = null;FlashLinux - 2009 Página | 69


public NodoArbol(int nombre) { this.nombre = nombre; izquierda = null; derecha = null; }//método que nos permite crear un nuevo elemento e insertarlo en el arbol public void insertar_elemento(int nombre) { if (nombre < this.nombre) { if (izquierda == null) { izquierda = new NodoArbol(nombre); } else { izquierda.insertar_elemento(nombre); } } if (nombre > this.nombre) { if (derecha == null) { derecha = new NodoArbol(nombre); } else { derecha.insertar_elemento(nombre); } } }}Implementación de la clase arbol:

import javax.swing.JOptionPane;public class arbol { NodoArbol raiz; public arbol() { raiz = null; } //metodo que nos permite insertar un Nodo en al arbol. public void insertar_nodo(int nombre, String preg) { if (raiz == null) { raiz = new NodoArbol(nombre, preg); } else { raiz.insertar_elemento(nombre, preg); } } //para realizar la operación, en este caso, utilizamos el recorrido en preorden, ustedes pueden utilizar cualquier tipo de recorrido.FlashLinux - 2009 Página | 70

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas public String realizar_operacion() { String resultado = preorden(raiz); return resultado; } private String preorden(NodoArbol nodo) { String cadena = new String(); String eligeme = ""; if (nodo != null) { //realizamos la pregunta, si y solo si, exista un subarbol izquierdo y/o derecho. if (nodo.derecha != null || nodo.izquierda != null) { eligeme = JOptionPane.showInputDialog(nodo.pregunta + "\nIngrese: si / no"); } //si la respuesta ingresada es "NO", entonces recorrer el suarbol derecho. if (eligeme.compareTo("no") == 0) { cadena = preorden(nodo.derecha); } //si la respuesta ingresada es "SI", entonces recorrer el suarbol izquierdo. else if (eligeme.compareTo("si") == 0) { cadena = preorden(nodo.izquierda); } else { //caso contrario mostrar la respuesta final... cadena = "Entonces es un: " + nodo.pregunta; } } else { cadena = ""; } return cadena; }}Implementación de la clase PruebaAnimales:import javax.swing.*;public class PruebaAnimales { public static void main(String args[]) { arbol a = new arbol(); //insertamos los Nodos en el arbol.. a.insertar_nodo(4, "¿Puede Volar?"); a.insertar_nodo(2, "¿Es un mamifero?"); a.insertar_nodo(1, "MURCIELAGO"); a.insertar_nodo(3, "CUERVO"); a.insertar_nodo(8, "¿Tiene cuernos?");FlashLinux - 2009 Página | 71

“ESTRUCTURA DE DATOS EN JAVA” Facultad de Ingeniería de Sistemas a.insertar_nodo(6, "¿Tiene Joroba?"); a.insertar_nodo(5, "CAMELLO"); a.insertar_nodo(7, "BABUINO"); a.insertar_nodo(9, "CIERVO"); JOptionPane.showMessageDialog(null, "\n" + a.realizar_operacion()); }}



BIBLIOGRAFÍA

• Algoritmo y estrucutura de datos I - MG. Abraham Etseban Gamarra Moreno

Wikipedia Enciclopedia Libre:

• PILAS EN JAVAhttp://es.wikipedia.org/wiki/Pila_(estructura_de_datos)• COLAS EN JAVAhttp://es.wikipedia.org/wiki/Cola_(estructura_de_datos)• COLA DE PRIORIDADEShttp://es.wikipedia.org/wiki/Cola_de_prioridades_(estructura_de_datos)• ARBOL Bhttp://es.wikipedia.org/wiki/B-tree• ARBOL BINARIO EN JAVAhttp://es.wikipedia.org/wiki/%C3%81rbol_binario

Programación en castellano:

• PILAS Y COLAShttp://www.programacion.com/tutorial/jap_data_alg/5/




NOTA IMPORTANTE:

Todas las notas, casos y comentarios expresados en el presente manual son propias de su autor.

Los contenidos que se ofrecen han sido recopilados de diferentes fuentes de

información, algunos códigos que se muestran en este manual fueron desarrollados en clase, por el

docente Abraham Gamarra Moreno, periodo (2008-II)

El autor no se responsabiliza por los daños o pérdida de

Información que lleve la realización de estas instrucciones.


COPYLEFTMarzo – 2009____________________________________________________

Dudas, sugerencias y/o comentarios: [email protected][email protected] los agradeceré...____________________________________________________


Administrador

Strikeout

Administrador

Insert Text

Edited by Foxit Reader Copyright(C) by Foxit Software Company,2005-2008 For Evaluation Only.

Administrador

Rectangle

Administrador

Rectangle

Administrador

Rectangle

Administrador

Rectangle

Administrador

Rectangle

Administrador

Rectangle

Administrador

Rectangle

Administrador

Rectangle

Administrador

Line

Administrador

Line



L ibres para pensar ;

L ibres para dec id ir ;

L ibres para crear . . .

Estructura 1 de Datos- Pilas, Colas, Arbole s

Documents

Transcript of Estructura 1 de Datos- Pilas, Colas, Arbole s