10.4.

Indices BTree
Es un arbol con raz donde:
Cada nodo x tiene:
1. N[x] n umero de claves
2. Las claves estan ordenadas de menor a mayor k
1
[x] < . . . < k
n
[x]
3. Una variable Boolean hoja[x] que es verdadera cuando el nodo x es una hoja.
Si el nodo es interno, tiene n[x] + 1 punteros a hijos
k
i
[x] separa los rangos que se almacenan
las hojas estan a la misma altura
dado un t 2, nodos excepto la raz tiene t 1 claves como mnimo y 2t 1 claves como
maximo.
Ejemplo:
Dibujo B-TREE del alfabeto con t = 3
P
C G M
T X
A B D E F J K L N O Q R S U V Y Z
Dado n 1, entonces cualquier n-key B-Tree de altura h y mnimo grado t2 satisface que
h log
t
n + 1
2
n 1 + (t 1)
h

i=1
2t
i1
1 + (t 1)

t
h
1
t 1

2t
h
1
68
1
t - 1
t - 1
t - 1 t - 1 t - 1 t - 1
t - 1
t - 1 t - 1
......
..... .....
#nodos
1
2
2t
/ k clave de b usqueda
/ x nodo en el B-tree (inicialmente la raz
/ leaf[x] indica si x es hoja
/ n[x] indica numero de claves en el nodo
/ c
i
[x] entrega puntero a hijo i en el nodo x
Procedure BTREE SEARCH(k, x)
i:= 1
while i n[x] and k > key
i
[x] do i := i + 1
if i n[x] and k = key
i
[x] then return (x, i)
if leaf[x] the return nil
else [ DISK READ(c
i
[x])
return BTREE SEARCH(k, c
i
[x])]
end BTREE SEARCH
Procedure BTREE SPLIT CHILD(x, i, y)
/ y es el i-esimo hijo de x que es dividido
z := Allocate Node()
leaf[z] := leaf[y]
n[z] := t 1
for j = 1 to t 1 do key
j
[z] := key
j+t
[y]
if not leaf[y] then
for j = 1 to t do c
j
[z] := c
j+t
[y]
n[y] := t 1
for j = n[x] + 1 downto i + 1 do c
j+1
[x] := c
j
[x]
c
i+1
[x] := z
for j = n[x] downto i do key
j+1
[x] := key
j
[x]
key
i
[x] := key
t
[y]
n[x] := n[x] + 1
DISK WRITE(y)
DISK WRITE(z)
DISK WRITE(x)
end BTREE SPLIT CHILD
69
Procedure BTREE INSERT(T, k)
r := root(T)
if n[r] = 2t 1 then [
s := Allocate Node()
root[T] := s
leaf[s] := false
n[s] := 0
c
1
[s] := r
BTREE SPLIT CHILD(s, 1, r)
BTREE INSERT NONFULL(s, k)]
else
BTREE INSERT NONFULL(r, k)
end BTREE INSERT
Procedure BTREE INSERT NONFULL(x, k)
i:= n[x]
if leaf[x] then [
while i 1 and k < key
i
[x] do [
key
i+1
[x] := key
i
[x]
i := i 1]
key
i+1
[x] := k
n[x] := n[x] + 1
DISK WRITE(x)
else [
while i 1 and k < key
i
[x] do i := i 1
i:= i+1
DISK READ(c
i
[x])
if n[c
i
[x]] = 2t 1 then [
BTREE SPLIT CHILD(x, i, c
i
[x])
if k > key
i
[x] then i:= i+1]
BTREE INSERT NONFULL(c
i
[x], k)
end BTREE INSERT NONFULL
70
11. Heaps
Una estructura heap puede ser vista como un arbol completo donde:
A[PARENT(i)] A[i]
Usando una representacion de arreglos de un arbol completo:
PARENT(i) return i/2
LCHILD(i) return 2i
RCHILD(i) return 2i + 1
Procedure BUILD HEAP(A)
heap size := length(A)
for i = (length(A)/2 dowto 1 do
HEAPIFY (A, i)
end BUILD HEAP
Procedure HEAPIFY (A, i)
l:= Left(i)
r:= Right(i)
if l heap size(A) and A[l] > A[i] then
largest := l
else
largest : = i
if r heap size(A) and A[r] > A[largest] then
largest := r
if largest = i then [
exchange(A[i], A[largest])
HEAPIFY (A, largest) ]
end HEAPIFY
El costo computacional del algoritmo HEAPIFY de un subarbol de tama no n y con raz i es de
(1) para encontrar la relaci on entre los elementos i, hijo izquierdo de i e hijo derecho de i, mas
el tiempo de ejecutar el HEAPIFY con un subarbol con la raz siendo uno de los hijos de i. Cada
subarbol hijo tiene como maximo un tama no 2n/3, con el peor caso cuando el ultimo nivel esta lleno
a la mitad. Entonces el sistema recurrente del algoritmo HEAPIFY es:
T(n) T(2n/3) +(1)
Con solucion T(n) = O(logn)
Para la funci on BUILD HEAP , se puede determinar un peor caso en forma simple. Hay un n umero
de O(n) de llamadas a HEAPIFY con cada una de ellas de O(logn). Entonces, el BUILD HEAP
tiene de orden O(nlogn).
Un lmite mas ajustado es por:
71
T(n)
0

k=logn

n
2
k+1
O(k) = O(n
0

k=logn
k
2
k
)
O(n
1/2
(1 1/2)
2
) = O(n)
72
12. Otros ndices
12.1. Tries
Este es un arbol donde los nodos son caracteres de un alfabeto y un camino desde la raz representa
una palabra dentro del vocabulario. Las hojas contienen punteros a la ocurrencias de esas palabras
en el base de datos.
Este es un texto. Un texto tiene muchas palabras. Palabras estn compuestas de caracteres
caracteres:79
compuestas:65
texto:12,22
palabras:41,50
12 22 41 50 65 79
c
a
o
p
t
Figura 21: Trie de vocabulario
Si se tienen n caracteres, entonces el arbol tiene como m aximo un camino de orden O(n), es decir,
insertar o buscar tendr a complejida de O(n). De acuerdo a la ley de Heaps, el vocabulario en un
texto de tama no n crece en e orden O(n

), donde es un valor entre 0 y 1, dependiendo del texto.

12.2.

Arbol de sujo
79
65 c
a
o
p
t
a l a b r a
41
50
.
' '
12
22
e
x t o
.
' '
Figura 22: Trie de sujo
73
79
65 c
a
o
p
t
8
41
50
.
' '
6
12
22
.
' '
Figura 23:

Arbol de sujo
12.3. Arreglo de sujo
Este es un texto. Un texto tiene muchas palabras. Palabras estn compuestas de caracteres
12 22 41 50 65 79
cara pala text
79 65 41 50 12 22
Figura 24: Arreglo de sujo
13. Introducci on General a Grafos
Denicion: Un grafo G consiste de dos conjuntos V y E. V es un conjunto nito y no vaco
de vertices. E es un conjunto de arcos, denidos en terminos de un par de vertices. En un grafo
adireccional, los pares (v
1
, v
2
) y (v
2
, v
1
) son equivalentes.
El orden de un grafo es el n umero de vertices que tiene. El grado de un vertice es el n umero de
non-loop arcos donde el vertice participa.
74
structureGRAPH
declare
EMPTY GRAPH() graph
ADDNODE(graph, edge) graph
ADDEDGE(graph, edge) graph
NODEOUT(graph, node) graph
EDGEOUT(graph, node) graph
EDGES(graph) Set(edge)
NODES(graph) Set(node)
ADJAC(graph, node) Set(node)
for all g GRAPH, i, j, k, l, v, w Node let
NODES(EMPTY GRAPH()) ::= EMPTY SET
NODES(ADDNODE(g, v)) ::= INSERT(NODES(g), v)
NODES(ADDEDGE(g, REL(i, j))) ::=
INSERT(INSERT(NODES(g), i)j)
EDGES(EMPTY GRAPH()) ::= EMPTY SET
EDGES(ADDNODE(g, v)) ::= EDGES(g)
EDGES(ADDEDGE(g, REL(i, j))) ::=
INSERT(EDGES(g), REL(i, j))
ADJAC(EMPTY GRAPH(), v) ::= EMPTY SET
ADJAC(ADDNODE(g, w), v) ::= ADJAC(g, v)
ADJAC(ADDEDGE(g, REL(i, j)), v) ::=
if v = i then INSERT(ADJAC(g, v), j)
else if v = j then INSERT(ADJAC(g, v), i)
else ADJAC(g, v)
NODEDOUT(EMPTY GRAPH(), v) ::= EMPTY GRAPH
NODEOUT(ADDNODE(g, w), v) ::=
if v = w then NODOUT(g, v)
else ADDNODE(NODEOUT(g, v), w)
NODEOUT(ADDEDGE(g, REL(i, j)), v) ::=
if v = i or v = j then NODOUT(g, v)
else ADDEDGE(NODEOUT(g, v), REL(i, j))
EDGEDOUT(EMPTY GRAPH(), REL(i, j)) ::= EMPTY GRAPH
EDGEOUT(ADDNODE(g, w), REL(i.j)) ::=
ADDNODE(EDGEOUT(g, REL(i, j)), v)
EDGEOUT(ADDEDGE(g, REL(k, l)), REL(i, j)) ::=
if REL(k, l) = REL(i, j) then g
else ADDEDGE(EDGEOUT(g, REL(i, j)), REL(k, l))
Consideramos dos tipos de representaciones de grafos: (1) Matriz de adyacencia, donde se crea
una matriz n n (n el n umero de vertices). El elemento (i, j) es 1 si existe un arco que une esos
vertices, de lo contrario es cero; (2) Listas de adyacencia, donde por cada vertice existe una lista
de los vertices.
Algoritmos importantes asociados a Grafos los dos tipos de recorridos. Dado un grafo no dirigido
G = (V, E) con n vertices, un arreglo A(n) inicialmente en cero y una lista (la) Q, los algoritmos
de recorrido que visita todos los nodos alcanzables desde v con G, Q y A variables globales:
75
Procedure DEPTH FIRST SEARCH(v)
A(v) := 1
for each w V adjacent to v do
if A(w) = 0 then call DEPTH FIRST SEARCH(w)
end DEPTH FIRST SEARCH(v)
Procedure BREADTH FIRST SEARCH(v)
A(v) := 1
inicializa Q con vertice v
while Q not empty do[
call DELETE(v, Q)
for all vertices w adjacent to v do [
if A(w) = 0 then [
call ADD(w, Q)
call A(w) := 1]]]
end BREADTH FIRST SEARCH(v)
76