Escolar Documentos
Profissional Documentos
Cultura Documentos
TDA Diccionario
Implementaciones sencillas
Árbol binario de búsqueda
Implementación del TDA Diccionario
Introducción
Dado un conjunto de elementos {X1, X2, ..., XN}, todos distintos entre
sí, se desea almacenarlos en una estructura de datos que permita la
implementación eficiente de las operaciones:
Camino de n1 y nk : secuencia de nodos n1, n2, ..., nk tal que ni es padre de ni+1,
para 1 <= i < k.
largo del camino: número de referencias que componen el camino
Ancestro: un nodo n es ancestro de un nodo m si existe un camino desde n a m;
Descendiente: un nodo n es descendiente de un nodo m si existe un camino
desde m a n.
Profundidad del nodo nk : largo del camino entre la raíz y el nodo nk.
Profundidad de la raíz es 0.
Altura de un nodo nk : máximo largo de camino desde nk hasta alguna hoja.
Altura de toda hoja es 0.
Altura de un árbol = Altura de la raíz
Altura de un árbol vacío = -1.
Arboles
A es la raíz del árbol.
A es padre de B, C y D.
E y F son hermanos, puesto que ambos son hijos de B.
E, J, K, L, C, P, Q, H, N y O son las hojas del árbol.
El camino desde A a J es único, lo conforman los nodos A-B-F-J y
es de largo 3.
D es ancestro de P, y por lo tanto P es descendiente de D.
L no es descendiente de C, puesto que no existe un camino desde C a
L.
La profundidad de C es 1, de F es 2 y de Q es 4.
La altura de C es 0, de F es 1 y
de D es 3.
La altura del árbol es 4 (largo del camino entre la raíz A y la hoja más
profunda, P o Q).
Arboles Binarios
class NodoArbolBinario<T> {
T elemento;
NodoArbolBinario<T> izq;
NodoArbolBinario<T> der;
}
Arboles Binarios
Es un árbol binario
Las hojas corresponden a los operandos de la expresión (variables o
constantes),
Los nodos restantes contienen operadores.
Recorridos del BT
P.e.:
En promedio harán falta 2.5 comparaciones para encontrar un dato en este árbol.
Coste de la búsqueda: esfuerzo de comparación
P.e.:
Buscar(7) 1 comparación
Buscar(2) 2 comparación
Buscar(5) 3 comparación
Buscar(3) 4 comparación
Cuándo el BST no está equilibrado (caso peor) los costes son lineales
Implementación: clase NodeBST
class NodeBST<E> {
private E data;
private NodeBST<E> left;
private NodeBST<E> right;
// Constructores
NodeBST(E data, NodeBST<E> left, NodeBST<E> right){
this.data = data;
this.left = left;
this.right = right;
}
NodeBST(E data){
this(data,null, null);
}
// getters, setters
}
Operaciones que nos interesan en la clase BST
Operaciones de búsqueda: Consultores:
E recover(E x) throws ItemNotFound int height()
E minRecover() boolean isEmpty()
Operaciones de inserción: double eMC()
void insertDuplicates(E x)
void insert(E x) throws ItemDuplicated Operaciones de recorrido:
void update(E x) String preOrder()
Operaciones de eliminación: String postOrder()
void remove(E x) throws ItemNotFound String inOrder()
void minRemove() String toLevels()
Implementación: clase BST
recover(5, 7 );
resC > 0
return recover(5, 7 .left)
5
recover(5, 2 );
resC < 0
return recover(5, 2 .right)
5
recover(5, 5 );
resC == 0
return 5
5
return 5 .dato;
Implementación: operaciones de inserción
public void insert(E x) throws ItemDuplicated {
root = insert(x, root);
}
protected NodeBST<E> insert(E x, NodeBST<E> actual)
throws ItemDuplicated {
NodeBST<E> res = actual;
if (actual == null) { res = new NodeBST<E>(x); }
else { //buscamos el lugar para inserción
int resC = actual.data.compareTo(x);
if (resC == 0 ) throw new ItemDuplicated(x + "esta duplcado");
if (resC < 0) res.right = insert(x, actual.right);
else
res.left = insert(x, actual.left);
}
return res;
}
Traza del método insert
Llamada inicial (insertamos el dato x=6)
root = insert(x, root),
insert(6, 7 );
resC > 0
7 .left = insert(6, 7 .left)
return 7
7 insert(6, 2 );
resC < 0
2 .right = insert(6, 2 .right)
return 2
2 insert(6, 5 );
resC < 0
5 .right = insert(6, 5 .right)
return 5
5 insert(6,NULL);
return 6
6
Implementación: operaciones de eliminación
//SII !isEmpty(): método para eliminar el minimo
public E minRemove() {
E min = minRecover();
this.root = minRemove(this.root);
return min;
}
minRemove( 7 );
7 .left = minRemove( 7 .left)
7 return 7
minRemove( 4 );
4 .left = minRemove( 4 .left)
4 return 4
minRemove( 1 );
1 .left == null
return 1 .right
3
Implementación: operaciones de eliminación
public void remove(E x) throws ItemNotFound {
this.root = remove(x, this.root);
}
protected NodeBST<E> remove(E x, NodeBST<E> actual) throws ItemNotFound {
NodeBST<E> res = actual;
if (actual == null) throw new ItemNotFound(x + "no esta");
int resC = actual.data.compareTo(x);
if (resC < 0) res.right = remove(x, actual.right);
else if (resC > 0) res.left = remove(x, actual.left);
else if(actual.left != null && actual.right != null){//dos hijos
res.data = minRecover(actuall.right).data;
res.right = minRemove(actual.right);
} else { //1 hijo o ninguno
res = (actual.left != null) ? actual.left : actual.right;
}
return res;
}
Traza de remove (nodo con un hijo)
Llamada inicial (eliminamos el dato x=5)
root = remove(x, root);
remove(5, 7 );
resC > 0
7 .left = remove(5, 7 .left)
7 return 7
remove(5, 2 );
resC < 0
2 .right = remove(5, 2 .right)
2
return 2
remove(5, 5 );
resC == 0
return 5 .left)
3
Traza de remove (nodo con dos hijos)
Llamada inicial (eliminamos el dato x=7)
root = remove(x, root),
remove(7, 7 );
resC == 0
7 .data = minRecover( 7 .right).data
minRemove( 8 );
8 .left == null
null
return 8 .right
Implementación: consultores y de recorrido
}
}