La descarga está en progreso. Por favor, espere

La descarga está en progreso. Por favor, espere

Tema 4 Árboles. Árboles binarios. Algoritmos básicos.

Presentaciones similares


Presentación del tema: "Tema 4 Árboles. Árboles binarios. Algoritmos básicos."— Transcripción de la presentación:

1 Tema 4 Árboles. Árboles binarios. Algoritmos básicos

2 Algoritmos básicos con árboles binarios Recorrido completo. Creación. Terminación anticipada. Recorridos especiales. Manejo de varias estructuras.

3

4 Aplicado a objetos de la clase Arbol: // Escribe las claves del árbol binario en preorden. static void preOrden (NodoArbol arbol) { if (arbol != null) { System.out.print (arbol.clave+" ") ; preOrden (arbol.iz); preOrden (arbol.de); } public void preorden () { preorden (raiz); } Orden de visita de nodos: 1, 2, 4, 9, 15, 5, 3, 8 y 7. Preferido para: Búsquedas. Recorrido en Preorden arbol nombre raiz

5 Aplicado a objetos de la clase Arbol: // Escribe las claves del árbol binario en orden central. static void ordenCentral (NodoArbol arbol) { if (arbol != null) { ordenCentral (arbol.iz); System.out.print (arbol.clave+" "); ordenCentral (arbol.de); } public void ordenCentral () { ordenCentral (raiz); } Orden de visita de nodos: 9, 4, 15, 2, 5, 1, 8, 3 y 7. Preferido para: Recorrido de acuerdo al orden físico de los nodos. En árboles binarios de búsqueda recupera la secuencia. arbol nombre raiz Recorrido en Orden Central

6 Aplicado a objetos de la clase Arbol: // Escribe las claves del árbol binario en postorden. static void postOrden (NodoArbol arbol) { if (arbol != null) { postOrden (arbol.iz); postOrden (arbol.de); System.out.print (arbol.clave + " ") ; } public void postOrden () { postOrden (raiz); } Orden de visita de nodos: 9, 15, 4, 5, 2, 8, 7, 3 y 1. Preferido para: Liberar memoria. Nodos buscados en los niveles más bajos del árbol. Recorrido en Postorden arbol nombre raiz

7 Ejemplo: suma de claves static int sumaClaves (NodoArbol nodoArbol) { int resul = 0; if (nodoArbol != null) { resul = nodoArbol.clave + sumaClaves (nodoArbol.iz); resul = resul + sumaClaves (nodoArbol.de); } return resul; } static int sumaClaves (Arbol a) { return sumaClaves (a.raiz); }

8 If (nodoArbol != null) { resul =sumaClaves(nodoArbol.iz)+nodoArbol.clave; resul =resul+sumaClaves(arbol.de); } else resul=0 null resul=04 resul= resul=07 resul=2+0 = 2 8 resul= null 11 resul=012 resul= resul= resul=5+4 = 9 6 resul = null resul= null resul=023 resul = resul =7+0 = 7 24 resul = null resul= null resul=031 resul= resul=9+0 = 9 32 resul =15+9= resul =15+24=39

9 Recorrido en Amplitud static void probarAmplitud (Arbol arbol) { NodoArbol referencia; ColaArbol colaArbol = new ColaArbol (); referencia = arbol.raiz; if (referencia != null) colaArbol.encolar (referencia); while (! colaArbol.colaVacia ()) { referencia = colaArbol.desencolar (); System.out.print (referencia.clave + " "); if (referencia.iz != null) colaArbol.encolar (referencia.iz); if (referencia.de != null) colaArbol.encolar (referencia.de); } Orden de visita de nodos: 1, 2, 3, 4, 5, 8, 7, 9 y arbol nombre raiz Arbol

10 Obtención de la copia de un árbol static Arbol copiarArbol (Arbol arbol) { Arbol resul = new Arbol(); resul.nombre = "Arbol copia"; if (arbol.raiz != null) resul.raiz = copiaArbol (arbol.raiz); return resul; } static NodoArbol copiaArbol (NodoArbol nodoArbol) { NodoArbol nuevoNodo = new NodoArbol(); nuevoNodo.clave = nodoArbol.clave; if (nodoArbol.iz != null) nuevoNodo.iz = copiaArbol (nodoArbol.iz); if (nodoArbol.de != null) nuevoNodo.de = copiaArbol(nodoArbol.de); return nuevoNodo; }

12 Insertar Criterio de inserción: Orden de los nodos. Operación juntar (join). Preguntar en qué rama se quiere insertar … No se permite insertar claves repetidas Búsqueda previa del dato que se quiere insertar para evitar repeticiones. Se inserta cuando alcanzamos el nivel más profundo (nodos hojas) de la rama seleccionada.

13 Inserción en árbol binario genérico static public void juntar (Arbol arbol, int dato, Arbol a1, Arbol a2) { if (a1.raiz == a2.raiz && a1.raiz != null) System.out.println ("no se pueden juntar, a1 y a2 son iguales") ; else { arbol.raiz = new NodoArbol () ; arbol.raiz.clave = dato; arbol.raiz.iz = a1.raiz; arbol.raiz.de = a2.raiz; if (arbol != a1) a1.raiz = null; if (arbol != a2) a2.raiz = null; }

14 Inserción en árbol binario de búsqueda. static NodoArbol insertar (NodoArbol arbol, int dato) { NodoArbol resul = arbol; if (arbol != null) if (arbol.clave < dato) arbol.de = insertar (arbol.de, dato); else if (arbol.clave > dato) arbol.iz = insertar (arbol.iz, dato); else System.out.println ("la clave ya existe"); else resul = new NodoArbol (dato); return resul; } public void insertar (int dato) { raiz = insertar (raiz, dato); } Método de objeto de Arbol Método static que recibe un NodoArbol y devuelve otro como resultado

15

16 Búsqueda en árbol binario. boolean encontrar (int dato) { return encuentra (raiz, dato); } static boolean encuentra (NodoArbol nodoArbol, int dato) { boolean resul; if (nodoArbol != null) if (nodoArbol.clave == dato) resul = true; else { resul = encuentra (nodoArbol.iz, dato); if (!resul) resul = encuentra (nodoArbol.de, dato); } else resul = false; return resul; }

17 Búsqueda en árbol binario de búsqueda. boolean encontrar (int dato) { return encuentra (raiz, dato); } public static boolean encuentra (NodoArbol nodoArbol, int dato) { boolean resul = false; if (nodoArbol != null) if (nodoArbol.clave == dato) resul = true; else if (nodoArbol.clave > dato) resul = encuentra (nodoArbol.iz, dato); else resul = encuentra (nodoArbol.de, dato); return resul; }

18 Ejemplo: Verificar que un árbol Binario es de Búsqueda static class arbolBusqueda { static int ant; static boolean primero = true; static boolean esBusqueda (NodoArbol arbol) { boolean resul; if (arbol == null) resul = true; else { resul = esBusqueda (arbol.iz); if (primero) primero = false; else if (arbol.clave <= ant) resul = false; if (resul) { ant = arbol.clave; resul = esBusqueda(arbol.de); } return resul; } static boolean esBusqueda (Arbol a) { return arbolBusqueda.esBusqueda (a.raiz); }

19 Eliminar una clave (I). Fase I. Se localiza la clave a eliminar (si existe). Fase II. Tres posibles situaciones: Clave está en un nodo hoja: Liberar memoria (innecesario en Java) y asignar el árbol a null. Clave tiene un único descendiente: Apuntar al subárbol no vacío y liberar memoria (innecesario en Java). Clave tiene dos descendientes: [Orden topológico anterior] Se localiza el descendiente más a la derecha del hijo izquierdo, se sustituye la clave a borrar por la clave encontrada, se cortocircuita el subárbol izquierdo y se borra (innecesario en Java) el nodo que contenía la clave sustituida.

20 Peculiaridades del lenguaje Java. Causa: Las referencias (punteros) se pasan por valor. Efecto: Los cambios realizados en la instancia actual sobre el puntero (NodoArbol) que se recibe como argumento no surten efecto cuando se retorna a la instancia de llamada. Técnica posible: Construir métodos que devuelvan actualizado el puntero (referencia) que se recibe como argumento. Ejemplo: static NodoArbol elimina (NodoArbol nodoArbol, int dato) { // cuerpo del método que modifica nodoArbol; return nodoArbol; } Eliminar una clave (II).

21

22 static void eliminarClave (Arbol arbol, int dato) { arbol.raiz = eliminarElemento (arbol.raiz, dato); } static NodoArbol eliminarElemento (NodoArbol arbol, int elem) { NodoArbol p; if (arbol != null) if (arbol.clave > elem) arbol.iz = eliminarElemento (arbol.iz, elem); else if (arbol.clave < elem) arbol.de = eliminarElemento (arbol.de, elem); else { p = arbol; if (arbol.iz == null) arbol= arbol.de; else if (arbol.de == null) arbol = arbol.iz; else arbol.iz = eliminar2Hijos (arbol.iz, p); } else System.out.println (" la clave buscada no existe"); return arbol; }

23 static NodoArbol eliminar2Hijos (NodoArbol arbol, NodoArbol p) { NodoArbol resul; if (arbol.de != null) { resul = arbol; arbol.de = eliminar2Hijos (arbol.de, p); } else { p.clave = arbol.clave; resul = arbol.iz; } return resul; }

24 static void eliminarArbol (Arbol arbol) { System.out.println ("NOTA: Este algoritmo es innecesario en Java "); System.out.println (Lo que no sucede en todos los lenguajes"); if (arbol.raiz == null) System.out.println ("Arbol vacio"); else { arbol.raiz =eliminaArbol (arbol.raiz); System.out.println (Faltaría 'destruir' la referencia principal (arbol)"); } static NodoArbol eliminaArbol (NodoArbol nodoArbol) { NodoArbol resul; if (nodoArbol != null) { nodoArbol.iz = eliminaArbol (nodoArbol.iz); nodoArbol.de = eliminaArbol (nodoArbol.de); System.out.println ("Clave antes de ser eliminada: +nodoArbol.clave); nodoArbol = null; resul = nodoArbol; } else resul = null; return resul; } Eliminar un árbol.

25

26 Condición de hoja: (nodoArbol.iz == null) && (nodoArbol.de == null) Ejemplo: Devuelve el número de hojas de un árbol static int cuentaHojas (Arbol arbol) { return contarHojas (arbol.raiz); } static int contarHojas (NodoArbol nodoArbol) { int resul = 0; if (nodoArbol != null) if ((nodoArbol.iz == null) && (nodoArbol.de == null)) resul = 1; else resul = contarHojas (nodoArbol.iz) + contarHojas (nodoArbol.de); return resul; } Tratamiento de hojas. Ejemplo.

27 Mecanismo: Se pasa un argumento entero (inicializado a 1) que se incrementa en cada llamada. Ejemplo: static void clavesNiveles (Arbol arbol) { clavesNiveles (arbol.raiz,1); } static void clavesNiveles (NodoArbol nodoArbol, int n) { if (nodoArbol != null) { System.out.println ("Clave: + nodoArbol.clave + " en el nivel: + n); clavesNiveles (nodoArbol.iz, n+1); clavesNiveles (nodoArbol.de, n+1); } Constancia de nivel. Recorrido en profundidad (I)

28 Ejemplo: Método que devuelve la altura de un árbol. static int pruebaAltura (Arbol arbol) { int resul = 0; if (arbol.raiz != null) resul = Altura.altura (arbol.raiz,1); return resul; } static int altura (NodoArbol nodoArbol, int n, int altura) { int resulIz, resulDe; if (nodoArbol != null) { if (n > altura) altura = n; resulIz = altura (nodoArbol.iz, n+1, altura); resulDe = altura (nodoArbol.de, n+1, altura); altura = Math.max (resulIz, resulDe); } return altura; } Constancia de nivel. Recorrido en profundidad (II)

29 Dos opciones: Iteración anidada en dos niveles. Modificar la cola de referencias a nodos del árbol para que incluya una variable con el nivel. Constancia de nivel. Recorrido en amplitud (I).

30 Sin modificar la cola de referencias. Dos iteraciones: Externa que recorre el árbol en niveles Interna que visita los nodos en amplitud Variables: contador: controla el recorrido del nivel actual: amplitud del nivel siguiente: número de hijos del siguiente nivel Constancia de nivel. Recorrido en amplitud (II)

31 static void ListarAmplitud (Arbol arbol) { Cola c = new tad_cola (); int actual, siguiente, contador, altura; NodoArbol p p = arbol.raiz; altura = 0; siguiente = 1; p = arbol; if (p != null ) c.encolar (p); while (!c.colaVacia()) { actual = siguiente; siguiente = 0; contador = 1; altura++; while (contador <= actual) { p = c.desencolar (); System.out.println ("clave: "+p.clave+" nivel: "+altura); contador++; if (p.iz != null) { c.encolar (p.iz); siguiente++; } if (p.de != null) { c.encolar (p.de); siguiente++; } Arbol.raiz p 1 altura = 0 siguiente =1;

32 static void ListarAmplitud (Arbol arbol) { Cola c = new tad_cola (); int actual, siguiente, contador, altura; c.inicializarCola (); NodoArbol p = arbol.raiz; altura = 0; siguiente = 1; p = arbol; if (p != null ) c.encolar (p); while (!c.colaVacia()) { actual = siguiente; siguiente = 0; contador = 1; altura++; while (contador <= actual) { p = c.desencolar (); System.out.println ("clave: "+p.clave+" nivel: "+altura); contador++; if (p.iz != null) { c.encolar (p.iz); siguiente++; } if (p.de != null) { c.encolar (p.de); siguiente++; } 1 altura = 0 siguiente = 1; Arbol.raiz p actual = 1 siguiente = 0 contador = 0 altura = 1

33 static void ListarAmplitud (Arbol arbol) { NodoArbol p p = arbol.raiz; Cola c = new tad_cola (); int actual, siguiente, contador, altura; altura = 0; siguiente = 1; c.inicializarCola (); p = arbol; if (p != null ) c.encolar (p); while (!c.colaVacia()) { actual = siguiente; siguiente = 0; contador = 1; altura++; while (contador <= actual) { p = c.desencolar (); System.out.println ("clave: "+p.clave+" nivel: "+altura); contador++; if (p.iz != null) { c.encolar (p.iz); siguiente++; } if (p.de != null) { c.encolar (p.de); siguiente++; } Arbol.raiz p clave es 1, altura 1 contador = Iteración interna: while (contador <= actual) salimos de la iteración interna actual = 1 contador = 0 altura = 1 siguiente = 1 siguiente = 2

34 static void ListarAmplitud (Arbol arbol) { NodoArbol p p = arbol.raiz; Cola c = new tad_cola (); int actual, siguiente, contador, altura; altura = 0; siguiente = 1; c.inicializarCola (); p = arbol; if (p != null ) c.encolar (p); while (!c.colaVacia()) { actual = siguiente; siguiente = 0; contador = 1; altura++; while (contador <= actual) { p = c.desencolar (); System.out.println ("clave: "+p.clave+" nivel: "+altura); contador++; if (p.iz != null) { c.encolar (p.iz); siguiente++; } if (p.de != null) { c.encolar (p.de); siguiente++; } Arbol.raiz P actual = 2 siguiente = 0 contador = 0 altura = while (contador <= actual) siguiente = P 3 2 clave es 2 y altura 2 contador = siguiente = 2 altura =1

35 static void ListarAmplitud (Arbol arbol) { NodoArbol p p = arbol.raiz; Cola c = new tad_cola (); int actual, siguiente, contador, altura; altura = 0; siguiente = 1; c.inicializarCola (); p = arbol; if (p != null ) c.encolar (p); while (!c.colaVacia()) { actual = siguiente; siguiente = 0; contador = 1; altura++; while (contador <= actual) { p = c.desencolar (); System.out.println ("clave: "+p.clave+" nivel: "+altura); contador++; if (p.iz != null) { c.encolar (p.iz); siguiente++; } if (p.de != null) { c.encolar (p.de); siguiente++; } iteración interna: while (contador <= actual) siguiente = P 3 clave es 3 y altura 2 4 contador = salimos de la iteración interna P clave es 3 y altura actual = 3 siguiente = 0 contador = 0 altura = 3

36 iteración interna: while (contador < =actual) P clave es 4 y altura actual = 3 contador = 1 clave es 5 y altura actual = 3 contador = 2 clave es 8 y altura 3 8 actual = 3 contador = 3 static void ListarAmplitud (Arbol arbol) { NodoArbol p p = arbol.raiz; Cola c = new tad_cola (); int actual, siguiente, contador, altura; altura = 0; siguiente = 1; c.inicializarCola (); p = arbol; if (p != null ) c.encolar (p); while (!c.colaVacia()) { actual = siguiente; siguiente = 0; contador = 1; altura++; while (contador <= actual) { p = c.desencolar (); System.out.println ("clave: "+p.clave+" nivel: "+altura); contador++; if (p.iz != null) { c.encolar (p.iz); siguiente++; } if (p.de != null) { c.encolar (p.de); siguiente++; }

37 class tElemento { int nivel; NodoArbol nodoArbol; tElemento (NodoArbol a, int n) { nivel = n; nodoArbol = a; } Constancia de nivel. Recorrido en amplitud (III) public class ColaArbolModificada { private NodoColaArbolModificada principio; private NodoColaArbolModificada fin; public ColaArbolModificada () { principio = null; fin = null; } Modificando la cola de referencias. class NodoColaArbolModificada { NodoColaArbolModificada siguiente; tElemento elem; NodoColaArbolModificada () { elem = null; siguiente = null; }

38 static void listarAmplitud (Arbol arbol) { NodoArbol p; int nivel; ColaArbolModificada cola = new ColaArbolModificada(); p = arbol.raiz; if (p != null) { tElemento elem = new tElemento (referencia, 1); cola.encolar(elem); while (! cola.colaVacia()) { elem = cola.desencolar (); p = elem.nodoArbol; nivel = elem.nivel; System.out.println("nivel: "+nivel+" "+p.clave+" "); if (p.iz != null) { elem = new tElemento(p.iz,nivel+1); cola.encolar(elem); } if (p.de != null) { elem = new tElemento (p.de, nivel+1); cola.encolar(elem); } Constancia de nivel. Recorrido en amplitud (IV) Ver codigo

39 static void listarAmplitud(Arbol arbol) { NodoArbol referencia; int nivel; ColaArbolModificada cola = new ColaArbolModificada(); p = arbol.raiz; if (p != null) { tElemento elem = new tElemento (p, 1); cola.encolar(elem); while (! cola.colaVacia()) { elem = cola.desencolar(); p = elem.nodoArbol; nivel = elem.nivel; System.out.println("nivel: "+nivel+" "+p.clave+" "); if (p.iz != null) { elem = new tElemento (p.iz, nivel+1); cola.encolar (elem); } if (p.de != null) { elem = new tElemento(p.de, nivel+1); cola.encolar(elem); } nodoArbol p nodoArbol p 1 p = 1 nivel =1; clave 1, Nivel

40 while (! cola.colaVacia()) { elem = cola.desencolar(); referencia = elem.nodoArbol; nivel = elem.nivel; System.out.println("nivel: "+nivel+" "+p.clave+" "); if (p.iz != null) { elem = new tElemento (p.iz,nivel+1); cola.encolar(elem); } if (p.de != null) { elem = new tElemento (p.de,nivel+1); cola.encolar(elem); } nodoArbol p p = 2 nivel =2; clave 1, nivel 1 clave 2, nivel nodoArbol p p = 3 nivel =3; clave 1, nivel 1 clave 2, nivel

41 while (! cola.colaVacia()) { elem = cola.desencolar(); referencia = elem.nodoArbol; nivel = elem.nivel; System.out.println("nivel: "+nivel+" "+p.clave+" "); if (p.iz != null) { elem = new tElemento (p.iz,nivel+1); cola.encolar(elem); } if (p.de != null) { elem = new tElemento (p.de,nivel+1); cola.encolar(elem); } nodoArbol p p = 4; n =2; clave 1, nivel 1 clave 2, nivel 2 clave 3, nivel 2 clave 4, nivel nodoArbol p p = 5; n =3; clave 1, nivel 1 clave 2, nivel 2 clave 3, nivel 2 clave 4, nivel 3 clave 5, nivel

42 while (! cola.colaVacia()) { elem = cola.desencolar(); referencia = elem.nodoArbol; nivel = elem.nivel; System.out.println("nivel: "+nivel+" "+p.clave+" "); if (p.iz != null) { elem = new tElemento (p.iz,nivel+1); cola.encolar(elem); } if (p.de != null) { elem = new tElemento (p.de,nivel+1); cola.encolar(elem); } nodoArbol p p = 8; n =3; clave 1, nivel 1 clave 2, nivel 2 clave 3, nivel 2 clave 4, nivel 3 clave 5, nivel 3 Clave 8, nivel 3 8 3

43

44 Verificar si dos árboles son iguales static boolean pruebaIguales (Arbol arboA, Arbol arbolB) { return sonIguales (arbol1.raiz, arbol2.raiz); } static boolean sonIguales (NodoArbol a, NodoArbol b) { boolean resul ; if ((a == null) && (b == null)) resul = true; else if ((a == null) || (b == null)) resul = false; else if (a.clave == b.clave) resul = sonIguales (a.iz, b.iz) && sonIguales (a.de, b.de); else resul = false; return resul; }

45 Arbol Binario de Búsqueda contenido en lista static boolean estaContenido (NodoArbol nodoArbol, NodoLista nodoLista) { boolean seguir, saltar; if (nodoArbol == null) seguir = true; else { seguir = estaContenido (nodoArbol.iz, nodoLista); if (seguir && (nodoLista != null)) if (nodoArbol.clave < nodoLista.clave) seguir = false; else { saltar = true; while ((nodoLista != null) && saltar) if (nodoArbol.clave == nodoLista.clave) saltar = false; else nodoLista = nodoLista.sig; if (!saltar) seguir = estaContenido (nodoArbol.de, nodoLista.sig); else seguir = false; } else seguir = false; } return seguir; } static boolean estaContenido (Arbol arbol, Lista lista) { return estaContenido (arbol.raiz, lista.inicio); }


Descargar ppt "Tema 4 Árboles. Árboles binarios. Algoritmos básicos."

Presentaciones similares


Anuncios Google