ESTRUCTURAS DE DATOS II CAPITULO 8

RBOLES
LUIS F. AGUAS B.

CAPITULO 8
1. rboles en general
Definiciones Terminologa

2. Recorrido de rboles

Postorden Preorden
Binarios AVL Multicamino Balanceado (B, B*, B+)

3. Tipos de rboles

LUIS F. AGUAS B.

RBOL: DEFINICIN
En computacin, un rbol es un modelo abstracto de una estructura jerrquica. Aplicaciones: Organigramas Sistemas de archivos Ambientes de programacin

Computadores

ventas

Manufactura

Reclamo

Local

Internacional

Laptops

Desktops

Europa

Asia

Canada

LUIS F. AGUAS B.

RBOLES EN GENERAL Y CON RAZ

En teora de grafos, un rbol (tree) es un conjunto de nodos (vrtices) y arcos (links, lines) conectando los nodos tal que: En muchas aplicaciones informticas, un nodo particular del el rbol es designado raz (root), los otros nodos son arreglados por niveles a partir del nodo raz. Nivel 0 Nivel 1 Nivel 2 rbol general Un rbol con raz
LUIS F. AGUAS B.

No existen ciclos cada dos nodos estn conectados por un solo arco

root

TERMINOLOGA DE RBOLES
Una estructura de rbol es una coleccin de nodos, c/u con:
Puede tener uno o mas sucesores Tiene solo un predecesor, con excepcin del nodo raz.

El nodo primero o inicial de la estructura rbol es llamado raz Un nodo predecesor es llamado padre (parent) Un nodo sucesor es llamado hijo (children) Nodos con padre comn son llamados hermanos (siblings) Un nodo sin hijos es llamado hoja (leaf) Un nodo que tiene hijos es llamado nodo interior Un nodo sin hijos es llamado nodo exterior Los nodos descendientes consisten en hijos, nietos hasta llegar a las hojas. Los nodos ancestros consisten de padres, abuelos hasta llegar a la raz.
LUIS F. AGUAS B.

TERMINOLOGA DE RBOLES

Un lado (edge or branch) es la lnea que conecta un padre con el hijo. Un camino (path) es la secuencia de lados que conectan un nodo con uno de sus descendientes La longitud del camino (path length) es el nmero de lados en el camino. La profundidad o nivel (depth o level) de un nodo es igual a la longitud de nodo a la raz. La profundidad de la raz es cero El peso (height) de un rbol es igual a la longitud del camino ms largo. Un sub-rbol (subtree) es un rbol formado al considerar un nodo como raz. El nuevo rbol consiste de este nodo y su descendencia.
LUIS F. AGUAS B.

2012 Octubre

Terminologa de rboles
PROPIEDAD VALOR

Numero de nodos Peso

10 3 H ACJL MN HBFE ACJE

Nodo raz Hojas

Nodos interiores Nodos a nivel 2

2012 Octubre

LUIS F. AGUAS B.

NODO DE RBOL

La clase TreeNode
Representa un node de un rbol Es similar al Nodo de lista doble (left y right)
public class TreeNode { private Object value; private TreeNode left; private TreeNode right; ...

Referencia al hijo izquierdo Referencia al hijo derecho

LUIS F. AGUAS B.

LA CLASE TREENODE 2
... ... ... // Constructores: public TreeNode (Object v) { value = v; left = null; right = null; }

public TreeNode (Object v, TreeNode lt, TreeNode rt) { value = v; left = lt; right = rt; } // Mtodos: public public public public public public }
LUIS F. AGUAS B.

Object getValue () { return value; } TreeNode getLeft () { return left; } TreeNode getRight () { return right; } void setValue (Object v) { value = v; } void setLeft (TreeNode lt) { left = lt; } void setRight (TreeNode rt) { right = rt; }
9

TREENODE EJEMPLO 1

public int countNodes (TreeNode root) { if (root == null) Caso base return 0; else return 1 + countNodes ( root.getLeft ( ) ) + countNodes ( root.getRight ( ) ); }
Para root

LUIS F. AGUAS B.

10

RBOLES Y RECURSIN
La estructura rbol es recursiva por naturaleza, los lados derechos e izquierdo son rboles tambin.
public void traverse (TreeNode root) { if (root != null) { visit (root); for (... <each child of the root> ) traverse (< that childs subtree>); } }
LUIS F. AGUAS B.

11

RECORRIDO PREORDEN
Preorden: primero visita la raz, entonces atraviesa la izquierda, y luego atraviesa el subarbol derecho
private void traversePreorder (TreeNode root) { if (root != null) { visit (root.getValue()); traversePreorder (root.getLeft()); traversePreorder (root.getRight()); } } A / \ B C / \ D E ABDEC

LUIS F. AGUAS B.

12

RECORRIDO POSORDEN
Posorden: primero atraviesa la izquierda entonces atraviesa el subarbol izquierdo, entonces visita la raz.
private void traversePostorder (TreeNode root) { if (root != null) { traversePostorder (root.getLeft()); traversePostorder (root.getRight()); process (root.getValue()); } } A / \ B C / \ D E DEBCA

LUIS F. AGUAS B.

13

RECORRIDO INORDEN
Inorden: primero atraviesa el subarbol izquierdo, entonces visita la raz, entonces atraviesa el subarbol derecho
private void traverseInorder (TreeNode root) { if (root != null) { traverseInorder (root.getLeft()); process (root.getValue()); traverseInorder (root.getRight()); } } A / \ B C / \ D E

DBEAC

LUIS F. AGUAS B.

14

RBOL CON ESTRUCTURAS NODO

LUIS F. AGUAS B.

15

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

// Fig. 20.17: Tree.java // Declaration of class TreeNode and class Tree. package com.deitel.jhtp5.ch20; // class TreeNode declaration class TreeNode { // package access members TreeNode leftNode; int data; TreeNode rightNode;

Nodo izquierdo y derecho

// initialize data and make this a leaf node public TreeNode( int nodeData ) { data = nodeData; leftNode = rightNode = null; // node has no children } // locate insertion point and insert new node; ignore duplicate values public synchronized void insert( int insertValue ) { Si no se puede ingresar ir a derecho // insert in left subtree if ( insertValue < data ) { // insert new TreeNode if ( leftNode == null ) leftNode = new TreeNode( insertValue );

LUIS F. AGUAS B.

16

30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

else // continue traversing left subtree leftNode.insert( insertValue ); } // insert in right subtree else if ( insertValue > data ) { // insert new TreeNode if ( rightNode == null ) rightNode = new TreeNode( insertValue );

Si el valor es mayor enotnces inserte al lado derecho

else // continue traversing right subtree rightNode.insert( insertValue );

} } // end method insert } // end class TreeNode // class Tree declaration public class Tree { private TreeNode root; // construct an empty Tree of integers public Tree() { root = null; } // insert a new node in the binary search tree public synchronized void insertNode( int insertValue ) {

LUIS F. AGUAS B.

17

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91

if ( root == null ) root = new TreeNode( insertValue ); // create the root node here else root.insert( insertValue ); // call the insert method } // begin preorder traversal public synchronized void preorderTraversal() { preorderHelper( root ); } // recursive method to perform preorder traversal private void preorderHelper( TreeNode node ) { if ( node == null ) return;

Recorrido System.out.print( node.data + " " ); // output node data preorderHelper( node.leftNode ); // traverse left subtree preorderHelper( node.rightNode ); // traverse right subtree
} // begin inorder traversal public synchronized void inorderTraversal() { inorderHelper( root ); }

en preorden

LUIS F. AGUAS B.

18

92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120

// recursive method to perform inorder traversal private void inorderHelper( TreeNode node ) { if ( node == null ) return; inorderHelper( node.leftNode ); // traverse left subtree System.out.print( node.data + " " ); // output node data inorderHelper( node.rightNode ); // traverse right subtree } // begin postorder traversal public synchronized void postorderTraversal() { postorderHelper( root ); } // recursive method to perform postorder traversal private void postorderHelper( TreeNode node ) { if ( node == null ) return; postorderHelper( node.leftNode ); // traverse left subtree postorderHelper( node.rightNode ); // traverse right subtree System.out.print( node.data + " " ); // output node data } } // end class Tree
LUIS F. AGUAS B.

Recorrido inorden

Recorrido postorden

19

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

// Fig. 20.18: TreeTest.java // This program tests class Tree. import com.deitel.jhtp5.ch20.Tree; public class TreeTest { public static void main( String args[] ) { Tree tree = new Tree(); int value; System.out.println( "Inserting the following values: " ); // insert 10 random integers from 0-99 in tree for ( int i = 1; i <= 10; i++ ) { value = ( int ) ( Math.random() * 100 ); System.out.print( value + " " ); tree.insertNode( value ); }

Insertar 10 enteros en rbol

System.out.println ( "\n\nPreorder traversal" ); tree.preorderTraversal(); // perform preorder traversal of tree System.out.println ( "\n\nInorder traversal" ); tree.inorderTraversal(); // perform inorder traversal of tree

Recorrido preorden

Recorrido inorden

LUIS F. AGUAS B.

20

RBOL IMPLEMENTACIN

26 27 28 29 30 31 32

System.out.println ( "\n\nPostorder traversal" ); Recorrido tree.postorderTraversal(); // perform postorder traversal of tree System.out.println(); } } // end class TreeTest

postorden

Inserting the following values: 39 69 94 47 50 72 55 41 97 73 Preorder traversal 39 69 47 41 50 55 94 72 73 97 Inorder traversal 39 41 47 50 55 69 72 73 94 97

Postorder traversal 41 55 50 47 73 72 97 94 69 39

LUIS F. AGUAS B.

21

RBOLES BINARIOS

rboles binarios

Estructuras de datos donde cada nodo tiene dos sucesores, a izquierda y a derecha. Ejemplo
Creacin Insercin Borrado

rbol balanceado: un rbol est balanceado cuando la altura de la trayectoria ms corta hacia una hoja no difiere de la altura de la trayectoria ms grande. Inconveniente de los binarios: se desbalancean fcilmente.
22

LUIS F. AGUAS B.

RBOLES AVL

rboles AVL
rbol binario balanceado en altura (BA(1)) en el que las inserciones y eliminaciones se efectan con un mnimo de accesos. rbol balanceado en altura:
Para cada nodo existe un lmite en la diferencia que se permite entre las alturas de cualquiera de los subrboles del nodo (BA(k)), donde k es el nivel de balance) Ejemplos:

LUIS F. AGUAS B.

23

RBOLES CARACTERSTICAS

Caractersticas
Estructura que debe ser respetada Mantener rbol, rotaciones restringidas a un rea local del rbol
Binario: profundos. Log2(N+1) Bsqueda:

rboles binarios paginados

Problemas de almacenamiento secundario, buffering, pginas de memoria, varios registros individuales, minimiza el nmero de accesos Problema: construccin descendente, como se elige la raz?, cmo va construyendo balanceado?

AVL: diferencia de 1. Bsqueda: 1.44 log2(N+2) (bsqueda en el peor caso)

LUIS F. AGUAS B.

24

RBOLES MULTICAMINO Y B

rboles multicamino
Generalizacin de rboles binarios, c/nodo tiene k punteros y k-1 claves (o registros), disminuye la profundidad del rbol,
Orden del rbol.

rboles B (balanceados)
Son rboles multicamino con una construccin especial en forma ascendente que permite mantenerlo balanceado a bajo costo.

LUIS F. AGUAS B.

25

RBOLES B PROPIEDADES

Propiedades de un rbol B de orden M:

Ningn nodo tiene ms de M hijos C/nodo (menos raz y los terminales) tienen como mnimo [M/2] hijos La raz tiene como mnimo 2 hijos (o sino ninguno) Todos los nodos terminales a igual nivel Nodos no terminales con K hijos contienen K-1 registros. Los nodos terminales tienen:
Mnimo [M/2] 1 registros Mximo M 1 registros

Formato del nodo

PO R1 P1 R2 P2 R3 P3 R4 P4 R5 P5 Nro de registros

LUIS F. AGUAS B.

26

RBOLES OPERACIONES

Definicin: nodo adyacente hermano Dos nodos son adyacentes hermanos si tienen el mismo padre y son apuntados por punteros adyacentes en el padre. Operaciones Bsqueda Borrado Creacin e insercin Modificacin

LUIS F. AGUAS B.

27

RBOLES: BSQUEDA

Bsqueda de informacin
Comienza desde el nodo raz
Busca la llave en el nodo Si no la localiza se toma el puntero anterior a la llave mayor Si no es puntero nulo se toma ese nodi y se repite del principio. Si es un puntero nulo el elemento no se encuentra en el rbol.

Performance
Orden M, # de nodos terminales N, N+1 punteros nulos. Accesos: Mejor caso: 1 lectura Pero caso: h lecturas (con h altura del rbol)

LUIS F. AGUAS B.

28

RBOLES: # LECTURAS

Como acotamos h Nivel # mnimo de descendientes 1 2 2 2 * [M/2] 3 2 * [M/2] * [M/2] . h 2 * [M/2]h-1

Relacin entre h y # de nodos N+1 >= 2 * [M/2]h-1 h <= [ 1 + log[M/2] ((N+1)/2) ] M = 512 y N = 1000000 h <= 3.37 (4 lecturas encuentra un registro)

LUIS F. AGUAS B.

29

ARBOLES ALGORITMOS

Algoritmo (iterativo)

encontro := false (k llave) tomar la raz Repeat N nro de elementos nodo Case k = llave del registro encontro := true k < llave( R1) P := Po k > llave (Rn) P := Pn otherwise P := Pi (i/ Ri-1 < k <Ri) EndCase IF P not null then leer nodo apuntado por P Until encontro or P null

Algoritmo (recursivo)

orden M estruc. del registro Record contador llaves llaves (arreglo M-1 elem.) hijos (arreglo M elem.) End Function Busca (Nrr, llave,NRR_encon, Pos_enc) Si Nrr = nulo entonces devuelve (no encon) sino lee nodo apuntado x NRR en pgina busca la llave en nodo; Pos:= Posicin donde encuentra o debera estarla llave Si encontro llave entonces nrr_encon := Nrr (nodo con la llave) pos_enc := pos (posicin dentro de llave) devuelve (encontrada) sino {busco en el nivel inferior} devuelve (busca( hijo[pos],llave, nrr_encon, pos_enc)) Fin S Fin S Fin Function

LUIS F. AGUAS B.

30

RBOLES: INSERCIN

Insercin (creacin) Los registros se insertan en un nodo Terminal Casos posibles El registro tiene lugar en el nodo Terminal (no se produce overflow): solo se hacen reacomodamientos internos en el nodo El registro no tiene lugar en el nodo Terminal (se produce overflow): el nodo se divide y los elementos se reparten entre los nodos, hay una promocin al nivel superior, y esta puede propagarse y generar una nueva raz.

LUIS F. AGUAS B.

31

RBOLES: INSERCIN

Algoritmo (iterativo) { reg.: reg a insertar fin: insercin finalizada encontro: elemento ya est P: puntero al nodo N_G: nodo sobredimensionado N : # reg } {busco la llave en el rbol} If encontro Then Informar llave repetida Else { insertar elemento } P := nil encontro := falso

Repeat IF nodo no esta lleno Then poner reg y reordenar encontro Else copiar el nodo en N_G insertar reg. en N_G reg:= centro de N_G nodo corr.:=1/2 N_G izq nodo nuevo:=1/2 N_G der If nodo raiz nuevo then generar nuevos punteros Until encontro

LUIS F. AGUAS B.

32

RBOLES: INSERCIN

Algoritmo (recursivo)
Funcion inserta (Nrr_Actual, llave, hijo_promo, llave_promo) Si Nrr_Actual = nulo entonces llave_promo := llave hijo_promo := nulo devuelve Promocion (promueve llave original y nulo) sino leer pgina de Nrr_acutal en pagina buscar llave en pagina pos := posicion donde deberia estar en llave Si encuentra llave entonces devuelve (error) valordevuelto := inserta(pagina, hijo[pos], llave, nrr_P_A, llave_P_a)

Si valordevuelto <> promocion entonces devuelve(valordevuelto) sino si hay espacio en pagina para llave_p_a entonces insertar(llave_p_a, nrr_p_a en pagina) promovida abajo devuelve (no promocion) sino divide( llave_p_a, nrr_p_a, pagina, llave_promo, hijo_promo, pgina_nueva) escribe pagina en archivo en nrr_actual escribe pagina_nueva en hijo_promo devuelve promocin promociona Fin Si llave_promo, hijo_promo fin funcion

LUIS F. AGUAS B.

33

DIRECTORIO

Procedimiento Divide (llave_i, nrr_i, pagina, llave_promo, hijo_promo, pagina_nueva ) copiar pagina + llave a un nodo que pueda contener a todas las llaves. insertar llave_i, nrr_i en los lugares correctos de la pagina crear una nueva pagina para pagina_nueva asignar a llave_promo el valor de la llave de enmedio de la pagina grande asignar a hijo_d_promo el nrr de pagina_nueva copiar las llaves y apuntadores que preceen a llave_promo en pagina idem posteriores pagina_nueva fin procedimiento

Performance
Mejor caso (sin overflow)
H lecturas 1 escritura

Peor caso (overflow hasta la raz, aumenta en uno el nivel del rbol)
H lecturas 2h+1 escrituras (dos por nivel ms la raz)

Estudios realizados
M = 10 25% divisiones M = 100 2% divisiones

LUIS F. AGUAS B.

34

RBOLES: ELIMINACIN

Eliminacin

Mejor caso: borra un elemento del nodo y no produce underflow, solo reacomodos ( # elementos >= [M/2]-1 Peor caso: se produce underflow, #elementos < [M/2] 1 Eliminar Dos soluciones
Redistribuir concatenar Nodo Terminal Nodo no Terminal ( llevar a un nodo Terminal)

LUIS F. AGUAS B.

35

RBOLES: REDISTRIBUIR

Redistribuir Cuando un nodo tiene underflow puede trasladarse llaves de un nodo adyacente hermano (en caso que este tenga suficientes elementos) Concatenacin: Si un nodo adyacente hermano est al mnimo (no le sobra ningn elemento) no se puede redistribuir, se concatena con un nodo adyacente disminuyendo el # de nodos (y en algunos casos la altura del rbol)

LUIS F. AGUAS B.

36

RBOLES: PERFORMANCE

Performance Mejor caso (borra de un nodo Terminal) H lecturas 1 escritura Peor caso (concatenacin lleva a decrementar el nivel del rbol en 1) 2h 1 lecturas H + 1 escrituras

LUIS F. AGUAS B.

37

RBOLES: ELIMINACIN

Algoritmo de eliminacin (iterativo)

{ fin: indica fin del borrado n_g:nodo tamao mayor al normal ady: nodo adyacente hermano reg: reg. a borrar} {buscar reg en el rbol } If reg no est en un nodo terminal then buscar el sucesor de reg en un nodo terminal intercalar reg con su sucesor { eliminacin de reg } fin := falso repeat remover reg y el puntero asociado If nodo corriente > [M/2] -1 elem. then fin := true else if es posible redistribuir then {redistribuir}{ady.>min.}

copiar ady y nodo actual en n_g dividir n_g promover nueva llave a padre armar nodo actual y ady con la mitad de n_g en c/u fin := true else {concatenar} elegir el mejor ady para concat. poner ady y nodo actual juntos y acoplarle elemnto nodo padre eliminar nodo que sobra y producir enganches nuevo reg elemento que bajo nodo padra y que debemos eliminar Until fin IF no hay registro en la raiz then nueva raiz nodo corriente liberar vieja raz

LUIS F. AGUAS B.

38

CAPITULO 8
PREGUNTAS Y RESPUESTAS

LUIS F. AGUAS B.

39