Operaciones de Unordered Dictionary

IMPORTANTE (OBJETIVOS):

Lograr O(K) en el worst-case de las siguientes operaciones:

1. add
2. find
3. replace
4. remove
En el caso de “add”, en el worst-case solo se puede lograr O(A*K), donde K = la longitud del key; A
= tamaño del alfabeto, es decir, el número de símbolos posibles.

Trie

Un trie es una estructura de datos de tipo árbol que permite la recuperación de información (de ahí
su nombre del inglés reTRIEval). La información almacenada en un trie es un conjunto de claves,
donde una clave es una secuencia de símbolos pertenecientes a un alfabeto. Las claves son
almacenadas en las hojas del árbol y los nodos internos son pasarelas para guiar la búsqueda. El
árbol se estructura de forma que cada letra de la clave se sitúa en un nodo de forma que los hijos
de un nodo representan las distintas posibilidades de símbolos diferentes que pueden continuar al
símbolo representado por el nodo padre.

Ejemplo: creando un trie para la palabra “aca”.

- Add(“aca”,
10) ->
Visualización

- Add(“acc”,
3) -> realiza la
misma cantidad
de pasos, con la
única diferencia
del paso 4,
donde el último
nodo no
“extendería” de
“a”, sino de “c”
y la referencia
sería 3 y no 10.
- find(“aca”) -> retorna una referencia (10).
- find(“abc”) -> no hay referencia, devuelve null.
- replace(“aca”,-5) -> se sigue el camino de “aca” [find(“aca”)] y se
reemplaza la referencia.

¿Cómo se vería esto en código?

Ya que el computador solo entiende números, ¿qué habría que hacer para crear nodos que
representen cada una de las letras de “aca”?

Tanto en ASCII como en UNICODE,los símbolos tienen representación numérica, la cual se puede
utilizar para crear un arreglo de las letras de nuestro alfabeto y acceder a las posiciones en O(1),
tal como se muestra a continuación.

class TrieNode<Value>
{
TrieNode[] children = new TrieNode[2];
Value valor;
}

int idx = (int) key.charAt(it) - (int)('a'); /* donde ‘key’ es nuestra palabra e

‘i’ cada una de las letras de esa palabra */

Con este enfoque, logramos O(K) tanto en el método find como en replace. Esto no puede lograrse
en el método add ya que al encontrar un nodo nulo, es necesario crear el arreglo, y aunque Java lo
hace automáticamente, crear ese arreglo y asignar null en cada posición es un trabajo que tiene un
costo de A, por lo que se logra O(A*K).

Para realizar el remove, se utilizará la técnica de “Data Structure Augmentation”, que consiste en
agregar información adicional al TrieNode para hacer más fácil la actividad de remover. Podemos
hacer esto tanto agregándole un contador a la clase TrieNode, para borrar el nodo cuando este
llegue a cero, como utilizando un stack sobre el que podamos hacer pop, para ir sacando los nodos
y devolviendo su referencia.

Operaciones de Ordered Dictionary

- find(key)
- add(key, value)
- remove(key)
- replace(key, value)
- min / max
- successor / predecessor
- rank / select

successor (x)
return: el siguiente key más pequeño, que es a la vez más grande que x.
add(9)
add(12)
add(5)
add(20)
add(6)
successor(5) -> 6
successor(12) -> 20
successor(20) -> null
 successor(13) -> 20, aunque el 13 no exista en el diccionario.

predecessor(x)
return: el key más grande, que es a la vez más pequeño que x.
predecessor(9)-> 6
predecessor(5)-> null
predecessor(20)-> 12
predecessor(13)-> 12, aunque el 13 no exista en el diccionario.

rank(x)
return: la posición que ocuparía x en el arreglo ordenado.
rank(5) -> 0
rank(20) -> 4l
rank(100) -> 5
rank(7) -> 2, aunque el 7 no exista en el diccionario.

select(x)
return: el key que ocupa la posición P en el arreglo ordenado e keys.
select(0) -> 5
rank(3) -> 12
rank(5) -> null

Binary Search Tree

Designamos los hijos de cada nodo como izquierdo o derecho (left o right), grabamos un key por
nodo en un binary tree respetando las siguientes propiedades:

1. Todos los descendientes en el subtree izquierdo del nodo A deben tener keys menores que
el key grabado en A.
2. Todos los descendientes en el subtree derecho del nodo A deben tener keys mayores que el
key grabado en A.