TDA MAPEO (ADT MAP)

Proporciona una forma de almacenar y recuperar datos basados en un identificador único: clave.
Clave: Atributo de un individuo que sirve para identificarlo en un conjunto de individuos.

size(): Retorna el número de entradas de M

isEmpty(): Testea si M es vacío
get(k) throws InvalidKeyException: Si M contiene una entrada e con clave igual a k, retorna el valor de v,
sino retorna null
put(k,v) throws InvalidKeyException: Si M no tiene una entrada con clave k, entonces agrega una entrada (k,v)
a M y retorna null. Si M ya tiene una entrada e con clave k, reemplaza el valor con v en e y retorna el valor viejo
de e.
remove(k) throws InvalidKeyException: Remueve de M la entrada con clave k y retorna su valor. Si M no tiene
entrada con clave k, retorna null
keys(): Retorna una colección iterable de las claves en M.
keys().iterator(): Retorna un iterador de claves.
values(): Retorna una colección iterable con los valores de las claves almacenadas en M
values().iterator(): Retorna un iterador de valores
entries(): Retorna una colección iterable con las entradas de M
entries().iterator(): Retorna un iterador de entradas
TDA DICCIONARIO (ADT DICTIONARY)
Un Diccionario maneja entradas del tipo <K, V> igual que el Mapeo, pero a diferencia de este permite
múltiples entradas con la misma clave.

size(): Retorna el número de entradas de D

isEmpty(): Testea si D está vacío
find(K key) throws InvalidKeyException: Si D contiene una entrada e con clave igual a key, entonces
retorna e, sino retorna null
findAll(K key) throws InvalidKeyException: Retorna una colección iterable conteniendo todas las
entradas con clave igual a key
insert(K key, V value) throws InvalidKeyException: Inserta en D una entrada e con clave key y valor
value y retorna la entrada e
remove( Entry<K,V> e ) throws InvalidEntryException: Remueve de D una entrada e, retornando la
entrada removida; ocurre un error si e no está en D
entries(): Retorna una colección iterable con las entradas clave-valor de D.
TDA CONJUNTO
Un conjunto se define como una estructura de datos que almacena una colección de elementos
distintos. Es una estructura de datos fundamental que se utiliza para almacenar y manipular un grupo
de objetos, donde cada objeto es único. El conjunto no permite elementos duplicados.

Un conjunto, caracterizado con el tipo Set<E>, tiene definidas las operaciones:

insert(x): Inserta un elemento x el conjunto
delete(x): Elimina el elemento x del conjunto
member(x): Retorna true si x pertenece al conjunto
intersection(S): Interseca al conjunto con otro conjunto S y retorna un nuevo conjunto intersección
unión(S): Une al conjunto con el conjunto S y retorna un nuevo conjunto unión
complement(): Calcula y retorna el complemento del conjunto (solo se puede implementar si el
dominio es finito)
iterator(): Retorna un iterador con los elementos del conjunto

ENTRY<K,V> (Key, Value)

public interface Entry<K,V> {
public K getKey(); // Retorna la clave de la entrada
public V getValue(); // Retorna el valor de la entrada
}

TABLAS DE HASH
Representación (implementación) de una colección de elementos, para que las operaciones de
búsqueda, inserción y eliminación sean constantes, o por lo menos mejor que O(n).
Para ello existen 2 variantes:

1) HASH ABIERTO
En lugar de tener una colección de elementos, particionamos la colección en BUCKETS o CUBETAS,
entonces dado un elemento podemos saber en qué cubeta debería estar. Si logramos una buena
distribución de elementos entre las cubetas, cada cubeta debería tener n/#cubetas de elementos.
Donde n es la cantidad de elementos de la colección.
Así las interacciones se limitan solo a esa cubeta y no a toda la colección de elementos (buscar,
insertar, eliminar).

Arreglo de Cubetas:
El arreglo tiene C cubetas y c/u es una lista de elementos

Para asociar la cubeta con el elemento usamos

hash(k) que retorna la cubeta donde debería
estar.

hash(ex) = j
 2) HASH CERRADO
Diferencia de hash abierto ya que el vacío en el Hash cerrado diferencia cuando en un lugar hubo
elementos y luego se borraron, y un lugar donde nunca hubo elementos.
Hace un recorrido circular para buscar un elemento, ya que comienza en la casilla donde debería
estar el elemento, va hacia el final y vuelve a empezar hasta que llega a esa casilla nuevamente. El
punto de corte es el índice desde donde comencé a buscar.

TDA ÁRBOL (ADT TREE)

Almacena jerárquicamente elementos -> nodos.
Nodo de más arriba -> raíz (no tiene padre), los demás solo tienen un único padre.
Nodos hermanos: nodos que tienen el mismo padre.
Nodos externos u hojas: si no tiene hijos.
Nodos internos: si tiene hijos.

RELACIÓN BINARIA (entre dos nodos)

Ancestro: si está en la misma línea de derivación (hacia arriba). La raíz es

ancestro de todos.
Ancestro propio: si está en la misma línea pero debajo de él (él es ancestro)
Descendiente: si está en la misma línea de derivación (hacia abajo).
Descendiente propio: los elementos de los cuales él es descendiente (los
que están arriba de él).

Subárbol: árboles que se generan dentro del principal.

Arco dirigido: dirección directa de la relación (única dirección de arco) Osea (A,B)
Arco no dirigido: dirección de arco ida y vuelta. Osea (A,B) y (B,A)
Camino: línea consecutiva de nodos conectados, no necesariamente tiene que ser
siguiendo las direcciones de las flechas.

ÁRBOL ORDENADO
Se dice cuando existe un orden lineal para los hijos de cada nodo. Es decir, se puede identificar el primer hijo, el
segundo hijo y así sucesivamente. Tal orden se visualiza de izquierda a derecha de acuerdo a tal ordenamiento.

IMPLEMENTACION DE METODOS
//Métodos genéricos
size(): Retorna el número de nodos del árbol isEmpty(): Testea si el árbol tiene o no nodos
iterator(): Retorna un iterador con los elementos ubicados en los nodos del árbol
positions(): Retorna una colección iterable de los nodos del árbol
replace(v,e): Reemplaza con e y retorna el elemento ubicado en v.

//Métodos de acceso (reciben y retornan posiciones)

root(): Retorna la raíz del árbol, error si el árbol está vacío
parent(v): Retorna el padre de v, error si v es la raíz
children(v): Retorna una colección iterable conteniendo los hijos del nodo v
//Métodos de consulta
isInternal(v): Testea si v es un nodo interno
isExternal(v): Testea si v es una hoja
isRoot(v): Testea si v es la raíz

//Métodos de modificación (agregados por la cátedra a [GT])

createRoot(e): crea un nodo raíz con rótulo e
addFirstChild(p,e): agrega un primer hijo al nodo p con rótulo e
addLastChild(p,e): agrega un último hijo al nodo p con rótulo e
addBefore(p,rb,e): Agrega un nodo con rótulo e como hijo de un nodo padre p dado. El nuevo nodo
se agregará delante de otro nodo hermano rb también dado.
addAfter(p,lb,e): Agrega un nodo con rótulo e como hijo de un nodo padre p dado. El nuevo nodo
se agregará detrás de otro hermano lb también dado.

//Métodos de modificación (agregados por la cátedra a [GT])

removeExternalNode(p): Elimina la hoja p
removeInternalNode(p): Elimina el nodo interno p. Los hijos del nodo eliminado lo reemplazan en el
mismo orden en el que aparecen. La raíz se puede eliminar si tiene un único hijo.
removeNode(p): Elimina el nodo p.
TDA ÁRBOL BINARIO (ADT BINARY-TREE)
Árbol ordenado que cumple:
➔ Cada nodo tiene a lo sumo dos hijos (0, 1 o 2)
➔ Cada nodo hijo es hijo izquierdo o hijo derecho.
➔ El hijo izquierdo precede al derecho en el orden de los hijos de un nodo.

Árbol binario propio: cada nodo tiene 0 o dos hijos. Sino, es un árbol binario impropio:

Un árbol binario T es o vacío, o consiste de:

● Un nodo r, llamado la raíz de T, que contiene un rótulo (o elemento)
● Un árbol binario -> subárbol izquierdo de T y un subárbol derecho de T
RECORRIDOS DE LOS ÁRBOLES
Existen 4 maneras sistemáticas de visitar todos los nodos de un Árbol T con raíz r:
1. PreOrden (previo) = prefijo
2. PostOrden (posterior) = posfijo
3. InOrden (simétrico) = infijo
4. Por Niveles

en ÁRBOLES GENERALES
1 - dentro de la estructura 2 - fuera de la estructura
 en ÁRBOLES BINARIOS
1 - dentro de la estructura 2 - fuera de la estructura

Preorden: La raíz r de T se visita 1ro y luego se visitan recursivamente cada uno de los subárboles de r.
Posorden: La raíz r de T se visita luego de visitar recursivamente cada uno de los subárboles de r.
Inorden (simétrico): 1ro se recorre recursivamente el 1er hijo de la raíz r, luego se visita la raíz y luego se visita
recursivamente al resto de los hijos de r.
Por niveles: Visita todos los nodos con profundidad p antes de recorrer todos los nodos con profundidad p+1.
Nivel: Subconjunto de nodos que tienen la misma profundidad.