Conceptos Básicos de Algorítmica

Conceptos Bsicos de Algortmica
Rosa Ma Jimnez
Conrado Martnez
U. Politcnica Catalunya
1 de octubre de 2013
Queda prohibida la reproduccin parcial o la modificacin, por

cualesquiera medios, de estas transparencias sin el consentimiento
expreso de los autores. Puede accederse a la copia principal de este
documento electrnico en la web, enlazarse, realizarse cuntas
copias se desee y difundirlas pblicamente a travs de la web u otros
medios, siempre y cuando no se altere su contenido en absoluto.
El consentimiento para la reproduccin, modificacin o uso total o
parcial de estas transparencias con fines exclusivamente docentes
est automticamente garantizado, tanto en la Univ. Politcnica de
Catalunya (UPC) como en cualquier otra institucin de enseanza,
superior o no, de cualquier pas y siempre y cuando: a) se respete el
debido crdito a los autores; b) los derechos de copia, reproduccin,
modificacin y uso total o parcial aplicables a los materiales
derivados sean los mismos aqu expresados. Por favor, envie un
e-mail a alg -at- lsi.upc.edu si est interesado en la
reproduccin, modificacin o uso total o parcial de estas
transparencias con cualquier fin, includos los fines docentes.
Anlisis de Algoritmos
Divide y vencers
rboles binarios de bsqueda
rboles balanceados (AVLs)
Tablas de Hash
Colas de prioridad
Grafos y Recorridos
Eficiencia de un algoritmo = consumo de recursos de

cmputo: tiempo de ejecucin y espacio de memoria
Anlisis de algoritmos Propiedades sobre la eficiencia
de algoritmos
Comparar soluciones algortmicas alternativas
Predecir los recursos que usar un algoritmo o ED
Mejorar los algoritmos o EDs existentes y guiar el diseo
de nuevos algoritmos
En general, dado un algoritmo A cuyo conjunto de entradas es

A su eficiencia o coste (en tiempo, en espacio, en nmero de
operaciones de E/S, etc.) es una funcin T de A en N (o Q o R,
segn el caso):
T :AN
T ()
Ahora bien, caracterizar la funcin T puede ser muy
complicado y adems proporciona informacin inmanejable,
difcilmente utilizable en la prctica.
Sea An el conjunto de entradas de tamao n y Tn : An N la

funcin T restringida a An .
Coste en caso mejor:
Tmejor (n) = mn{Tn () | An }.
Coste en caso peor:
Tpeor (n) = m
ax{Tn () | An }.
Coste promedio:
Tavg (n) =
Pr() Tn ()
An
X
k0
k Pr(Tn = k).
Para todo n 0 y para cualquier An

Tmejor (n) Tn () Tpeor (n).
Para todo n 0
Tmejor (n) Tavg (n) Tpeor (n).
Estudiaremos generalmente slo el coste en caso peor:

1
Proporciona garantas sobre la eficiencia del algoritmo, el

coste nunca exceder el coste en caso peor
Es ms fcil de calcular que el coste promedio
Una caracterstica esencial del coste (en caso peor, en caso

mejor, promedio) es su tasa de crecimiento
Ejemplo
1
Funciones lineales: f (n) = a n + b f (2n) 2 f (n)
Funciones cuadrticas:
q(n) = a n2 + b n + c q(2n) 4 q(n)
Se dice que las funciones lineales y las cuadrticas tienen

tasas de crecimiento distintas. Tambin se dice que son de
rdenes de magnitud distintos.
n log2 n
n2
n3
2n
2
4
8
4
8
16
64
16
24
64
512
256
64 256
4096
262144
160 1024 32768 6,87 1010
384 4096 262144 4,72 1021
` N
L
C
Q
E
` + 1 2N 2(L + N )
4C
8Q
E2
log2 n
1
2
3
4
5
6
n
2
4
8
16
32
64
Los factores constantes y los trminos de orden inferior son

irrelevantes desde el punto de vista de la tasa de crecimiento:
p.e. 30n2 + n tiene la misma tasa de creciemiento que

2n2 + 10n notacin asinttica
Definicin
Dada una funcin f : R+ R+ la clase O(f ) (O-grande de f )
es
O(f )={g:R+ R+ | n0 c nn0 :g(n)cf (n)}
En palabras, una funcin g est en O(f ) si existe una constante

c tal que g < c f para toda n a partir de un cierto punto (n0 ).
Aunque O(f ) es un conjunto de funciones por tradicin se

escribe a veces g = O(f ) en vez de g O(f ). Sin embargo,
O(f ) = g no tiene sentido.
Propiedades bsicas de la notacin O:
1
Si lmn g(n)/f (n) < + entonces g = O(f )
2
Es reflexiva: para toda funcin f : R+ R+ , f = O(f )
Es transitiva: si f = O(g) y g = O(h) entonces f = O(h)
Para toda constante c > 0, O(f ) = O(c f )
Los factores constantes no son relevantes en la notacin

asinttica y los omitiremos sistemticamente: p.e. hablaremos
de O(n) y no de O(4 n); no expresaremos la base de
logaritmos (O(log n)), ya que podemos pasar de una base a
otra multiplicando por el factor apropiado:
logc x =
logb x
logb c
Otras notaciones asintticas son (omega) y (zita). La

primera define un conjunto de funciones acotada inferiormente
por una dada:
(f )={g:R+ R+ | n0 c>0 nn0 :g(n)cf (n)}
La notacin es reflexiva y transitiva; si lmn g(n)/f (n) > 0

entonces g = (f ). Por otra parte, si f = O(g) entonces
g = (f ) y viceversa.
Se dice que O(f ) es la clase de las funciones que crecen no

ms rpido que f . Anlogamente, (f ) es la clase de las
funciones que crecen no ms despacio que f .
Finalmente,
(f ) = (f ) O(f )
es la clase de la funciones con la misma tasa de crecimiento
que f .
La notacin es reflexiva y transitiva, como las otras. Es
adems simtrica: f = (g) si y slo si g = (f ). Si
lmn g(n)/f (n) = c donde 0 < c < entonces g = (f ).
Propiedades adicionales de las notaciones asintticas (las

inclusiones son estrictas):
1
Para cualesquiera constantes < , si f es una funcin

creciente entonces O(f ) O(f ).
Para cualesquiera constantes a y b > 0, si f es creciente,

O((log f )a ) O(f b ).
Para cualquier constante c > 1, si f es creciente,

O(f ) O(cf ).
Los operadores convencionales (sumas, restas, divisiones,

etc.) sobre clases de funciones definidas mediante una
notacin asinttica se extienden de la siguiente manera:
A B = {h | f A g B : h = f g},
donde A y B son conjuntos de funciones. Expresiones de la
forma f A donde f es una funcin se entender como
{f } A.
Este convenio nos permite escribir de manera cmoda
expresiones como n + O(log n), nO(1) , (1) + O(1/n).
Regla de las sumas:

(f ) + (g) = (f + g) = (max{f, g}).
Regla de los productos:
(f ) (g) = (f g).
Reglas similares se cumplen para las notaciones O y .
Anlisis de algoritmos iterativos
El coste de una operacin elemental es (1).
Si el coste de un fragmento S1 es f y el de S2 es g
entonces el coste de S1 ; S2 es f + g.
Si el coste de S1 es f , el de S2 es g y el coste de evaluar B

es h entonces el coste en caso peor de
if B then S1
elseS2
end if
es max{f + h, g + h}.
Si el coste de S durante la i-sima iteracin es fi , el coste

de evaluar B es hi y el nmero de iteraciones es g
entonces el coste T de
while B do
S
end while
es
i=g(n)
X
T (n) =
fi (n) + hi (n).
i=1
Si f = max{fi + hi } entonces T = O(f g).
Anlisis de algoritmos recursivos

El coste (en caso peor, medio, . . . ) de un algoritmo recursivo
T (n) satisface, dada la naturaleza del algoritmo, una ecuacin
recurrente: esto es, T (n) depender del valor de T para
tamaos menores. Frecuentemente, la recurrencia adopta una
de las dos siguientes formas:
T (n) = a T (n c) + g(n),
T (n) = a T (n/b) + g(n).
La primera corresponde a algoritmos que tiene una parte no
recursiva con coste g(n) y hacen a llamadas recursivas con
subproblemas de tamao n c, donde c es una constante.
La segunda corresponde a algoritmos que tienen una parte no
recursiva con coste g(n) y hacen a llamadas recursivas con
subproblemas de tamao (aproximadamente) n/b, donde b > 1.
Teorema
Sea T (n) el coste (en caso peor, en caso medio, ...) de un
algoritmo recursivo que satisface la recurrencia
(
f (n)
si 0 n < n0
T (n) =
a T (n c) + g(n) si n n0 ,
donde n0 es una constante, c 1, f (n) es una funcin
arbitraria y g(n) = (nk ) para una cierta constante k 0.
Entonces
si a < 1
(n )
k+1
T (n) = (n ) si a = 1
(an/c ) si a > 1.
Teorema
Sea T (n) el coste (en caso peor, en caso medio, . . . ) de un
algoritmo recursivo que satisface la recurrencia
(
f (n)
si 0 n < n0
T (n) =
a T (n/b) + g(n) si n n0 ,
donde n0 es una constante, b > 1, f (n) es una funcin
arbitraria y g(n) = (nk ) para una cierta constante k 0.
Sea = logb a. Entonces
si < k
(n )
k
T (n) = (n log n) si = k
(n )
si > k.
Divide y vencers
Tablas de Hash
Colas de prioridad
Grafos y Recorridos
Introduccin
El principio bsico de divide y vencers (en ingls, divide and

conquer; en cataln, dividir per conquerir) es muy simple:
1
Si el ejemplar (instancia) del problema a resolver es

suficientemente simple, se encuentra la solucin mediante
algn mtodo directo.
En caso contrario, se divide o fragmenta el ejemplar dado

en subejemplares x1 , . . . , xk y se resuelve, independiente
y recursivamente, el problema para cada uno de ellos.
Las soluciones obtenidas y1 , . . . , yk se combinan para

obtener la solucin al ejemplar original.
El esquema de divide y vencers expresado en

pseudocdigo tiene el siguiente aspecto:
procedure DIVIDE _ Y _ VENCERAS(x)
if x es simple then
return SOLUCION _ DIRECTA(x)
else
hx1 , x2 , . . . , xk i := DIVIDE(x)
for :=1 to k do
yi := DIVIDE _ Y _ VENCERAS(xi )
end for
return COMBINA(y1 , y2 , . . . , yk )
end if
end procedure
Ocasionalmente, si k = 1, se habla del esquema de

reduccin.
El esquema de divide y vencers se caracteriza

adicionalmente por las siguientes propiedades:
No se resuelve ms de una vez un mismo subproblema
El tamao de los subejemplares es, en promedio, una
fraccin del tamao del ejemplar original, es decir, si x es
de tamao n, el tamao esperado de un subejemplar
cualquiera xi es n/ci donde ci > 1. Con frecuencia, esta
condicin se cumplir siempre, no slo en promedio.
Coste de los algoritmos divide y vencers

El anlisis de un algoritmo divide y vencers requiere, al igual
que ocurre con otros algoritmos recursivos, la resolucin de
recurrencias. En su caso ms simple las recurrencias son de la
forma
(
f (n) + a T (n/b) si n > n0 ,
T (n) =
b(n)
si n n0 .
Este tipo de recurrencia corresponde al coste T (n) de un
algoritmo donde conocemos la solucin directa siempre que n,
el tamao de x, sea menor o igual a n0 , y en caso contrario, se
descompone el ejemplar en subejemplares cuyo tamao es
aproximadamente n/b, haciendose a llamadas recursivas,
siendo f (n) el coste conjunto de las funciones de dividir y de
combinar. Si bien es habitual que a = b, existen muchas
situaciones en las que esto no sucede.
Teorema
Si g(n) = (nk ) entonces la solucin de la recurrencia
(
g(n) + a T (n/b) si n > n0 ,
T (n) =
f (n)
si n n0 ,
donde a 1 y b > 1 son constantes, satisface
si < k,
(g(n))
T (n) = (g(n) log n) si = k
(n )
si > k,
siendo = logb a.
Demostraci 21 n: Supondremos que n = n0 bj . Aplicando la

recurrencia repetidamente,
T (n) = gf (n) + a T (n/b)
= g(n) + a f (n/b) + a2 T (n/b2 )
=
= g(n) + a g(n/b) + + aj1 g(n/bj1 )
+ aj T (n/bj )
X
=
ai g(n/bi ) + aj T (n0 )
0i<j
ai
n k
0i<j
bi
+ aj f (n0 )
X a i
+ aj f (n0 ).
= nk
bk
0i<j
Puesto que f (n0 ) es una constante y tenemos que el segundo

trmino es (n ) ya que
aj = alogb (n/n0 ) = alogb n a logb n0
= (blogb alogb n )
= (nlogb a ) = (n ).
Ahora tenemos tres casos diferentes a considerar: segn que
a/bk sea menor, igual o mayor que 1. Alternativamente, ya que
= logb a, segn que sea mayor, igual o menor que k. Si
k > (equivalentemente, a/bk < 1) entonces la suma que
aparece en el primer trmino es una serie geomtrica acotada
por una constante, es decir, el primer trmino es (nk ). Como
asumimos que k > , es el primer trmino el que domina y
T (n) = (nk ) = (g(n)).
Si = k, tendremos que a/bk = 1 y la suma vale j; ya que

j = logb (n/n0 ) = (log n), conclumos que
T (n) = (nk log n) = (g(n) log n). Finalmente, si k <
entonces a/bk > 1 y el valor de la suma es

X a i (a/bk )j 1
a j
=
=
k
k
b
a/b 1
bk
0i<j
= (
n
) = (nk ).
nk
Por tanto, es el segundo trmino el que en este caso domina y

T (n) = (n ).
Bsqueda dicotmica
Problema: Dado un vector A[1..n] de n elementos, en orden
creciente, y un elemento x, determinar el valor i, 0 i n, tal
que A[i] x < A[i + 1] (convendremos que A[0] = y
A[n + 1] = +).
Si el vector A fuese vaco la respuesta es sencilla, pues x no
est en el vector. Pero para poder obtener una solucin
recursiva efectiva, debemos realizar la siguiente
generalizacin: dado un segmento o subvector A[` + 1..u 1],
0 ` u n + 1, ordenado crecientemente, y tal que
A[`] x < A[u], determinar el valor i, ` i u 1, tal que
A[i] x < A[i + 1]. Este es un ejemplo clsico de inmersin de
parmetros.
Ahora s, si ` + 1 = u, el segmento en cuestin no contiene
elementos y i = u 1 = `.
. Llamada inicial: B IN S EARCH(A, x, 0, n + 1)

procedure B IN S EARCH(A, x, `, u)
Require: 0 ` < u n + 1, A[`] x < A[u]
Ensure: Retorna i tal que A[i] x < A[i + 1] y ` i < u
if ` + 1 = u then
return `
else
m := (` + u) div 2
if x < A[m] then
return B IN S EARCH(A, x, `, m)
else
return B IN S EARCH(A, x, m, u)
end if
end if
end procedure
La llamada inicial es B IN S EARCH(()A, x, 0, A.SIZE() + 1),

donde A.SIZE() nos da n, el nmero de elementos del vector A.
Prescindiendo de la pequea diferencia entre el tamao real de
los subejemplares y el valor n/2, el coste de la bsqueda
binaria o dicotmica viene descrito por la recurrencia
B(n) = (1) + B(n/2),
n > 0,
y B(0) = b0 , ya que en cada llamada recursiva slo se hace

otra, sea en el subvector a la izquierda, sea el subvector a la
derecha del punto central. Empleando el Teorema 1,
= log2 1 = 0 y por lo tanto B(n) = (log n).
Algoritmo de Karatsuba y Ofmann
El algoritmo tradicional de multiplicacin tiene coste (n2 ) para

multiplicar dos enteros de n bits, ya la suma de dos enteros de
(n) bits tiene coste (n).
231 x 659 =
+
=
=
9 x 231 + 5 x 231 x 10
6 x 231 x 100
2079 + 11550 + 138600
152229
Tambi 12 es de coste cuadr 21 tico el algoritmo de

multiplicacin a la rusa:
z := 0
.x=X y =Y
while x 6= 0 do
. Inv: z + x y = X Y
if x es par then
x := x div 2; y := 2 y
else
x := x 1; z := z + y
end if
end while
.z =X Y
Supongamos que x e y son dos nmeros positivos de n = 2k

bits (si n no es una potencia de 2 x e y no tienen ambos la
misma longitud, podemos aadir 0s por la izquierda para que
as sea).
Una idea que no funciona:
x y = (A 2n/2 + B) (C 2n/2 + D)
= A C 2n + (A D + B C) 2n/2 + B D.
Efectuada la descomposicin x = hA, Bi y y = hC, Di, se

calculan 4 productos (A B, A D, B C y B D) y se combinan
las soluciones mediante sumas y desplazamientos (shifts). El
coste de estas operaciones es (n). Por lo tanto, el coste de la
multiplicacin mediante este algoritmo divide y vencers viene
dado por la recurrencia
M (n) = (n) + 4 M (n/2),
n>1
cuya solucin es M (n) = (n2 ). En este caso = 1, a = 4 y

b = 2, y = 1 < c = log2 4 = 2.
El algoritmo de Karatsuba y Ofmann (1962) realiza la

multiplicacin dividiendo los dos nmeros como antes pero se
realizan las siguientes 3 multiplicaciones (recursivamente)
U =AC
V =BD
W = (A + B) (C + D)
Y el resultado se calcula a partir de las tres soluciones
obtenidas
x y = U 2n + (W (U + V )) 2n/2 + V.
El algoritmo requiere realizar 6 adiciones (una de ellas es de

hecho una resta) frente a las 3 adiciones que se empleaban en
el algoritmo anterior. El coste mejora pues el coste de las
funciones de divisin y de combinacin del algoritmo de
Karatsuba y Ofmann sigue siendo lineal y disminuye el nmero
de llamadas recursivas.
M (n) = (n) + 3 M (n/2)

M (n) = (nlog2 3 ) = (n1,5849625... )
La constante oculta en la notacin asinttica es grande y la
ventaja de este algoritmo frente a los algoritmos bsicos no se
manifiesta hasta que n es relativamente grande (del orden de
200 a 250 bits por multiplicando).
procedure M ULT(x,y, i, j, i0 , j 0 )
Require: 1 i j n, 1 i0 j 0 n, j 0 i0 = j i
Ensure: Devuelve el producto de x[i..j] por y[i0 ..j 0 ]
n := j i + 1
if n < M then
Usar un mtodo simple para calcular el resultado
else
m := (i + j) div 2; m0 := (i0 + j 0 ) div 2
U := MULT(x, y, m + 1, j, m0 + 1, j 0 )
V := MULT(x, y, i, m, i0 , m0 )
U.DECALA _ IZQUIERDA(n)
W1 := x[i..m] + y[i0 ..m0 ]
W2 := x[m + 1..j] + y[m0 + 1..j 0 ]
Aadir un bit a W1 W2 si es necesario
W := M ULT(W1 , W2 , . . .)
W := W (U + V )
W.DECALA _ IZQUIERDA(n div 2)
return U + W + V
end if
end procedure
Ordenacin por fusin

El algoritmo de ordenacin por fusin (mergesort) fue uno de
los primeros algoritmos eficentes de ordenacin propuestos.
Diversas variantes de este algoritmo son particularmente tiles
para la ordenacin de datos residentes en memoria externa. El
propio mergesort es un mtodo muy eficaz para la ordenacin
de listas enlazadas.
La idea bsica es simple: se divide la secuencia de datos a
ordenar en dos subsecuencias de igual o similar tamao, se
ordena recursivamente cada una de ellas, y finalmente se
obtiene una secuencia ordenada fusionando las dos
subsecuencias ordenadas. Si la secuencia es suficientemente
pequea puede emplearse un mtodo ms simple (y eficaz
para entradas de tamao reducido).
Supondremos que nuestra entrada es una lista enlazada L

conteniendo una secuencia de elementos x1 , . . . , xn . Cada
elemento se almacena en un nodo con dos campos: info
contiene el elemento y next es un apuntador al siguiente nodo
de la lista (indicaremos que un nodo no tiene sucesor con el
valor especial next = null). La propia lista L es, de hecho, un
apuntador a su primer nodo. La notacin apuntador campo
indica el campo referido del objeto apuntado como en C y C++.
Es equivalente a la expresin p.campo de Pascal y Modula-2.
procedure S PLIT(L, L0 , n)
Require: L = [`1 , . . . , `m ], m n
Ensure: L = [`1 , . . . , `n ], L0 = [`n+1 , . . . , `m ]
p := L
while n > 1 do
p := p next
n := n 1
end while
L0 := p next; p next := null
end procedure
procedure M ERGE S ORT(L, n)
if n > 1 then
m := n div 2
S PLIT(L, L0 , m)
M ERGE S ORT(L, m)
M ERGE S ORT(L0 , n m)
. fusiona las listas L y L0
L := M ERGE(L, L0 )
end if
end procedure
Para fusionar razonamos de la siguiente forma: Si L L0 es

vaca la lista resultante es la otra lista, es decir, la que
eventualmente es no vaca. Si ambas son no vacas
comparamos sus respectivos primeros elementos: el menor de
los dos ser el primer elemento de la lista fusionada resultante
y a continuacin vendr la lista resultado de fusionar la sublista
que sucede a ese primer elemento con la otra lista.
procedure M ERGE(L, L0 )
if L = null then return L0
end if
if L0 = null then return L
end if
if L inf o L0 inf o then
L next := M ERGE(L next, L0 )
return L
else
L0 next := M ERGE(L, L0 next)
return L0
end if
end procedure
Cada elemento de L y L0 es visitado exactamente una vez,

por lo que el coste de la operacin M ERGE es proporcional a la
suma de los tamaos de las listas L y L0 ; es decir, su coste es
(n). La funcin definida es recursiva final y podemos obtener
con poco esfuerzo una versin iterativa algo ms eficiente.
Observese que si el primer elemento de la lista L es igual al
primer elemento de L0 se pone en primer lugar al que proviene
de L, por lo que M ERGE S ORT es un algoritmo estable.
El coste de M ERGE S ORT viene descrito por la recurrencia
l n m
j n k
+M
M (n) = (n) + M
2
2

n
= (n) + 2 M
2
cuya solucin es M (n) = (n log n), aplicando el segundo
caso del Teorema 1.
Algoritmo de Strassen
El algoritmo convencional de multiplicacin de matrices tiene

coste (n3 ) para multiplicar dos matrices n n.
for i := 1 to n do
for j := 1 to n do
C[i, j] := 0
for k := 1 to n do
C[i, j] := C[i, j] + A[i, k] B[k, j]
end for
end for
end for
Para abordar una solucin con el esquema divide y vencers

se descomponen las matrices en bloques:

B11 B12
C11 C12
A11 A12
=
A21 A22
B21 B22
C21 C22
donde C11 = A11 B11 + A12 B21 , etc.
Cada bloque de C requiere dos multiplicaciones de bloques de

tamao n/2 n/2 y dos sumas cuyo coste es (n2 ). El coste
del algoritmo divide y vencers as planteado tendra coste
M (n) = (n2 ) + 8 M (n/2),
es decir, M (n) = (n3 ).
Para conseguir una solucin ms eficiente debemos reducir el
nmero de llamadas recursivas.
Strassen (1969) propuso una forma de hacer justamente esto.

En el libro de Brassard & Bratley se detalla una posible manera
de hallar la serie de frmulas que producen el resultado
deseado. Un factor que complica las cosas es que la
multiplicacin de matrices no es conmutativa, a diferencia de lo
que sucede con la multiplicacin de enteros.
Se obtienen las siguientes 7 matrices n/2 n/2, mediante 7
productos y 14 adiciones/sustracciones
M1 = (A21 + A22 A11 ) (B11 + B22 B12 )
M2 = A11 B11
M3 = A12 B21
M4 = (A11 A21 ) (B22 B12 )
M5 = (A21 + A22 ) (B12 B11 )
M6 = (A12 A21 + A11 A22 ) B22
M7 = A22 (B11 + B22 B12 B21 )
Mediante 10 adiciones/sustracciones ms, podemos obtener

los bloques de la matriz resultante C:
C11 = M2 + M3
C12 = M1 + M2 + M5 + M6
C21 = M1 + M2 + M4 M7
C22 = M1 + M2 + M4 + M5
Puesto que las operaciones aditivas tienen coste (n2 ), el
coste del algoritmo de Strassen viene dado por la recurrencia
M (n) = (n2 ) + 7 M (n/2),
cuya solucin es (nlog2 7 ) = (n2,807... ).
El algoritmo de Strassen tuvo un enorme impacto terico ya

que fue el primer algoritmo de multiplicacin de matrices cuya
complejidad era o(n3 ); lo cual tena tambin implicaciones en el
desarrollo de algoritmos ms eficientes para el clculo de
matrices inversas, de determinantes, etc. Adems era uno de
los primeros casos en que las tcnicas algortmicas superaban
lo que hasta el momento pareca una barrera infranqueable.
En aos posteriores se han obtenido algoritmos todava ms
eficientes. El ms eficiente conocido es el de Coppersmith y
Winograd (1986) cuyo coste es (n2,376... ).
El algoritmo de Strassen no es competitivo en la prctica,
excepto si n es muy grande (n 500), ya que las constantes y
trminos de orden inferior del coste son muy grandes.
QuickSort
Q UICK S ORT (Hoare, 1962) es un algoritmo de ordenacin que
usa el principio de divide y vencers, pero a diferencia de los
ejemplos anteriores, no garantiza que cada subejemplar tendr
un tamao que es fraccin del tamao original.
La base de quicksort es el procedimiento de PARTICIN: dado
un elemento p denominado pivote, debe reorganizarse el
segmento como ilustra la figura.
El procedimiento de particin sita a un elemento, el pivote, en

su lugar apropiado. Luego no queda ms que ordenar los
segmentos que quedan a su izquierda y a su derecha. Mientras
que en M ERGE S ORT la divisin es simple y el trabajo se realiza
durante la fase de combinacin, en Q UICK S ORT sucede lo
contrario.
Para ordenar el segmento A[`..u] el algoritmo queda as
procedure Q UICK S ORT(A, `, u)
Ensure: Ordena el subvector A[`..u]
if u ` + 1 M then
usar un algoritmo de ordenacin simple
else
PARTICIN(A, `, u, k)
. A[`..k 1] A[k] A[k + 1..u]
Q UICK S ORT((A, `, k 1)
Q UICK S ORT(A, k + 1, u)
end if
end procedure
En vez de usar un algoritmo de ordenacin simple (p.e.

ordenacin por insercin) con cada segmento de M o menos
elementos, puede ordenarse mediante el algoritmo de
insercin al final:
Q UICK S ORT(A, 1, A.SIZE())
I NSERT S ORT(A, 1, A.SIZE())
Puesto que el vector A est quasi-ordenado tras aplicar
Q UICK S ORT, el ltimo paso se hace en tiempo (n), donde
n = A.SIZE().
Se estima que la eleccin ptima para el umbral o corte de
recursin M oscila entre 20 y 25.
Existen muchas formas posibles de realizar la particin. En

Bentley & McIlroy (1993) se discute un procedimiento de
particin muy eficiente, incluso si hay elementos repetidos.
Aqu examinamos un algoritmo bsico, pero razonablemente
eficaz.
Se mantienen dos ndices i y j de tal modo que A[` + 1..i 1]
contiene elementos menores o iguales que el pivote p, y
A[j + 1..u] contiene elementos mayores o iguales. Los ndices
barren el segmento (de izquierda a derecha, y de derecha a
izquierda, respectivamente), hasta que A[i] > p y A[j] < p o se
cruzan (i = j + 1).
procedure PARTICIN(A, `, u, k)
Require: ` u
Ensure: A[`..k 1] A[k] A[k + 1..u]
i := ` + 1; j := u; p := A[`]
while i < j + 1 do
while i < j + 1 A[i] p do
i := i + 1
end while
while i < j + 1 A[j] p do
j := j 1
end while
if i < j + 1 then
A[i] :=: A[j]
end if
end while
A[`] :=: A[j]; k := j
end procedure
El coste de Q UICK S ORT en caso peor es (n2 ) y por lo tanto

poco atractivo en trminos prcticos. Esto ocurre si en todos o
la gran mayora de los casos uno de los subsegementos
contiene muy pocos elementos y el otro casi todos, p.e. as
sucede si el vector est ordenado creciente o
decrecientemente. El coste de la particin es (n) y entonces
tenemos
Q(n) = (n) + Q(n 1) + Q(0)
= (n) + Q(n 1) = (n) + (n 1) + Q(n 2)
n
X
X
= =
(i) =
i
i=0
0in
= (n ).
Sin embargo, en promedio, el pivote quedar ms o menos
centrado hacia la mitad del segmento como sera deseable
justificando que quicksort sea considerado un algoritmo de
divide y vencers.
Para analizar el comportamiento de QUICKSORT slo importa el

orden relativo de los elementos. Tambin podemos investigar
exclusivamente el nmero de comparaciones entre elementos,
ya que el coste total es proporcional a dicho nmero.
Supongamos que cualquiera de los n! ordenes relativos
posibles tiene idntica probabilidad, y sea qn el nmero medio
de comparaciones.
X
qn =
E[# compar. | pivote es j-simo] Pr{pivote es j-simo}
1jn
(n 1 + qj1 + qnj )
1jn
1
n
1 X
(qj1 + qnj )
n
1jn
2 X
= n + O(1) +
qj
n
= n + O(1) +
0j<n
Para resolver esta recurrencia emplearemos el denominado

continuous master theorem (CMT).
El CMT considera recurrencias de divide y vencers con el

siguiente formato
X
Fn = tn +
n,j Fj ,
n n0
0j<n
para un entero positivo n0 , una funcin tn , denominada funcin

de peaje, y unos pesos n,j 0. Los pesos deben satisfacer
dos condiciones adicionales:
P
1
Wn = 0j<n n,j 1
P
2
Zn = 0j<n nj Wn,j
< 1.
n
El paso fundamental es hallar una funcin de forma (z) que
aproxima los pesos n,j .
Definicin
Dado un conjunto de pesos n,j , (z) es una funcin de forma
para el conjunto de pesos si
R1
1
0 (z) dz 1
2
existe una constante > 0 tal que

Z (j+1)/n

X

(z) dz = O(n )
n,j

j/n
0j<n
Un mtodo simple y que funciona usualmente para calcular

funciones de forma consiste en sustituir j por z n en n,j ,
multiplicar por n y tomar el lmite para n .
(z) = lm n n,zn
n
Las extensiones a los nmeros reales de muchas funciones

discretas son inmediatas, p.e. j 2 z 2 .
Para los nmeros binomiales se puede emplear la
aproximacin

zn
(z n)k
.
k!
k
La extensin de los factoriales a los reales viene dada por la
funcin gamma de Euler (z) y la de los nmeros armnicos
es la funcin (z) = d lndz(z) .
Por ejemplo, en quicksort los pesos son todos iguales:
n,j = n2 . La funcin de forma correspondiente es
(z) = lmn n n,zn = 2.
Teorema (Roura, 1997)

Sea Fn descrita por la recurrencia
X
Fn = tn +
n,j Fj ,
0j<n
sea (z) una funcin de forma correspondiente a los pesos

n,j , y tn = (na (log n)b ), para a 0 y b > 1 constantes.
R1
R1
Sea H = 1 0 (z)z a dz y H0 = (b + 1) 0 (z)z a ln z dz.
Entonces
tn
si H > 0,
H + o(tn )
t
n
Fn = H0 ln n + o(tn log n) si H = 0 y H0 6= 0,
(n )
si H < 0,
donde x = es la nica solucin real no negativa de la
ecuacin
Z
1
(z)z x dz = 0.
1
0
Consideremos qn . Ya hemos visto que los pesos son

n,j = 2/n y tn = n 1. Por tanto (z) = 2, a = 1 y b = 0.
Puede comprobarse fcilmente que se dan todas las
condiciones necesarias para la aplicacin del CMT.
Calculamos
Z 1
z=1
H=1
2z dz = 1 z 2 z=0 = 0,
0
por lo que tendremos que aplicar el caso 2 del CMT y calcular

H0
z=1
Z 1

1
z2
2
0
z ln z
= .
H =
2z ln z dz =
2
2
0
z=0
Por lo tanto,
n ln n
+ o(n log n) = 2n ln n + o(n log n)
1/2
= 1,386 . . . n log2 n + o(n log n).
qn =
QuickSelect
El problema de la seleccin consiste en hallar el j-simo de
entre n elementos dados. En concreto, dado un vector A con n
elementos y un rango j, 1 j n, un algoritmo de seleccin
debe hallar el j-simo elemento en orden ascendente. Si j = 1
entonces hay que encontrar el mnimo, si j = n entonces hay
que hallar el mximo, si j = bn/2c entonces debemos hallar la
mediana, etc.
Es fcil resolver el problema con coste (n log n) ordenando
previamente el vector y con coste (j n), recorriendo el vector
y manteniendo los j elementos menores de entre los ya
examinados. Con las estructuras de datos apropiadas puede
rebajarse el coste a (n log j), lo cual no supone una mejora
sobre la primera alternativa si j = (n).
Q UICK S ELECT (Hoare, 1962), tambin llamado F IND y
one-sided Q UICK S ORT, es una variante del algoritmo
Q UICK S ORT para la seleccin del j-simo de entre n
elementos.
Supongamos que efectuamos una particin de un subvector

A[`..u], conteniendo los elementos `-simo a u-simo de A, y
tal que ` j u, respecto a un pivote p. Una vez finalizada la
particin, supongamos que el pivote acaba en la posicin k.
Por tanto, en A[`..k 1] estn los elementos `-simo a
(k 1)-simo de A y en A[k + 1..u] estn los elementos
(k + 1)-simo au-simo. Si j = k hemos acabado ya que
hemos encontrado el elemento solicitado. Si j < k entonces
procedemos recursivamente en el subvector de la izquierda
A[`..k 1] y si j > k entonces encontraremos el elemento
buscado en el subvector A[k + 1..u].
procedure Q UICK S ELECT(A, `, j, u)

Ensure: Retorna el (j + 1 `)-simo menor elemento de A[`..u],
`ju
if ` = u then
return A[`]
end if
PARTICIN(A, `, u, k)
if j = k then
return A[k]
end if
if j < k then
return Q UICK S ELECT(A, `, j, k 1)
else
return Q UICK S ELECT(A, k + 1, j, u)
end if
end procedure
Puesto que Q UICK S ELECT es recursiva final es muy simple

obtener una versin iterativa eficiente que no necesita espacio
auxiliar.
En caso peor, el coste de Q UICK S ELECT es (n2 ). Sin
embargo, su coste promedio es (n) donde la constante de
proporcionalidad depende del cociente j/n. Knuth (1971) ha
(j)
demostrado que Cn , el nmero medio de comparaciones
necesarias para seleccionar el j-simo de entre n es:
Cn(j) = 2 (n + 1)Hn (n + 3 j)Hn+1j

(j + 2)Hj + n + 3
El valor mximo se alcanza para j = bn/2c; entonces
(j)
Cn = 2(ln 2 + 1)n + o(n).
Consideremos ahora el anlisis del coste promedio Cn

suponiendo que j adopta cualquier valor entre 1 y n con igual
probabilidad.
Cn = n + O(1)
1 X
+
E[nm. de comp. | el pivote es el k-simo] ,
n
1kn
puesto que el pivote es el k-simo con igual probabilidad para

toda k.
La probabilidad de que j = k es 1/n y entonces ya habremos

acabado. La probabilidad de continuar a la izquierda es
(k 1)/n y entonces se habrn de hacer Ck1 comparaciones.
Anlogamente, con probabilidad (n k)/n se continuar en el
subvector a la derecha y se harn Cnk comparaciones.
Cn = n + O(1) +
nk
1 X k1
Ck1 +
Cnk
n
n
n
1kn
2 X k
= n + O(1) +
Ck .
n
n
0k<n
Aplicando el CMT con la funcin de forma

lm n
obtenemos H = 1
R1
0
2zn
= 2z
n n
2z 2 dz = 1/3 y Cn = 3n + o(n).
Podemos obtener un algoritmo cuyo coste en caso peor sea

lineal si garantizamos que cada paso el pivote escogido divide
el vector en dos subvectores cuya talla sea una fraccin de la
talla del vector original, con coste O(n) (incluyendo la seleccin
del pivote). Entonces, en caso peor,
C(n) = O(n) + C(p n),
donde p < 1. Puesto que log1/p 1 = 0 < 1 conclumos que
C(n) = O(n). Por otra parte, es bastante obvio que
C(n) = (n); luego, C(n) = (n).
Este es el principio del algoritmo de seleccin de Rivest y Floyd
(1970).
La nica diferencia entre el algoritmo de seleccin de Hoare y

el de Rivest y Floyd reside en la manera en que elegimos los
pivotes. El algoritmo de Rivest y Floyd obtiene un pivote de
calidad empleando el propio algoritmo, recursivamente, para
seleccionar los pivotes!
De hecho, el algoritmo calcula una pseudomediana y elige sta
como pivote. Se subdivide el subvector A[`..u] en bloques de q
elementos (excepto posiblemente el ltimo bloque), con q
constante e impar, y para cada uno de ellos se obtiene su
mediana. El coste de esta fase es (n) y como resultado se
obtiene un vector con dn/qe elementos. Sobre dicho vector se
aplica el algoritmo de seleccin para hallar la mediana. Como
el pivote seleccionado es la pseudomediana de los n
elementos originales, ello garantiza que al menos
n/2q q/2 = n/4 elementos son mayores que el pivote.
Por lo tanto, el coste C(n) en caso peor satisface

C(n) = O(n) + C(n/q) + C(3n/4).
Utilizando la versin discreta del CMT, C(n) = O(n) si
3 1
+ < 1.
4 q
Rivest y Floyd usaron el valor q = 5 en su formulacin original
de este algoritmo.
Divide y vencers
Tablas de Hash
Colas de prioridad
Grafos y Recorridos
Definicin
Un rbol binario de bsqueda T es un rbol binario tal que o es
vaco o bien contiene un elemento x y satisface
1
Los subrboles izquierdo y derecho, L y R,

respectivamente, son rboles binarios de bsqueda.
Para todo elemento y de L, CLAVE(y) < CLAVE(x), y para

todo elemento z de R, CLAVE(z) > CLAVE(x).
Lema
Un recorrido en inorden de un rbol binario de bsqueda T
visita los elementos de T por orden creciente de clave.
Vamos a considerar ahora el diseo del algoritmo de bsqueda
en rboles binarios de bsqueda (BSTs), en lo sucesivo). Dada
la naturaleza recursiva de la definicin de BST es razonable
abordar el diseo de este algoritmo de manera recursiva.
Sea T el BST que representa al diccionario y k la clave
buscada. Si T = entonces k no se encuentra el diccionario y
ello se habr de indicar de algn modo conveniente. Si T no es
vaco entonces tendremos que considerar la relacin que
existe entre la clave del elemento x que ocupa la raz de T y la
clave dada k.
Si k = CLAVE(x) la bsqueda ha tenido xito y finalizamos,

retornando el elemento x (o la informacin asociada a x que
nos interesa). Si k < CLAVE(x), se sigue de la definicin de los
BSTs, que si hay un elemento en T cuya clave es k entonces
dicho elemento se habr de encontrar en el subrbol izquierdo
de T , por lo que habr que efectuar una llamada recursiva
sobre el hijo izquierdo de T . Anlogamente, si k > CLAVE(x)
entonces la bsqueda habr de continuar recursivamente en el
subrbol derecho de T .
template <typename Clave, typename Valor>

class Diccionario {
public:
...
void busca(const Clave& k,
bool& esta, Valor& v) const throw(error);
void inserta(const Clave& k,
const Valor& v) throw(error);
void elimina(const Clave& k) throw();
...
private:
struct nodo_bst {
Clave _k;
Valor _v;
nodo_bst* _izq;
nodo_bst* _der;
// constructora de la clase nodo_bst
nodo_bst(const Clave& k, const Valor& v,
nodo_bst* izq = NULL, nodo_bst* der = NULL);
};
nodo_bst* raiz;
static nodo_bst* busca_en_bst(nodo_bst* p,
const Clave& k) throw();
static nodo_bst* inserta_en_bst(nodo_bst* p,
const Clave& k, const Valor& v) throw(error);
static nodo_bst* elimina_en_bst(nodo_bst* p,
const Clave& k) throw();
static nodo_bst* juntar(nodo_bst* t1,
nodo_bst* t2) throw();
static nodo_bst* reubicar_max(nodo_bst* p) throw();
...
}
El mtodo BUSCA emplea el mtodo privado BUSCA _ EN _ BST.

ste ltimo recibe un apuntador p a la raz del BST en el que
se ha de hacer la bsqueda y una clave k. Devuelve un
apuntador, o bien nulo, si k no est presente en el BST, o bien
que apunta al nodo del BST que contiene la clave k.
void Diccionario<Clave,Valor>::busca(const Clave& k,
bool& esta, Valor& v) const throw(error) {
nodo_bst* p = busca_en_bst(raiz, k);
if (p == NULL)
esta = false;
else {
esta = true;
v = p -> _v;
}
}
La implementacin recursiva del mtodo privado

BUSCA _ EN _ BST es casi inmediata a partir de la definicin de
BST. Si el rbol es vaco su raz contiene la clave k,
devolvemos el apuntador p ya que apunta al lugar correcto (a
nulo o al nodo con la clave). En caso contrario, se compara k
con la clave almacenada en el nodo raz al que apunta p y se
prosigue recursivamente la bsqueda en el subrbol izquierdo
o derecho, segn toque.
// implementacin recursiva
Diccionario<Clave,Valor>::nodo_bst*
Diccionario<Clave,Valor>::busca_en_bst(nodo_bst* p,
const Clave& k) throw() {
if (p == NULL or k == p -> _k)
return p;
// p != NULL and k != p -> _k
if (k _k)
return busca_en_bst(p -> _izq, k);
else // p -> _k < k
return busca_en_bst(p -> _der, k);
}
Puesto que el algoritmo de buqueda recursivo es recursivo final

es inmediato obtener una versin iterativa.
// implementacin iterativa
Diccionario<Clave,Valor>::busca_en_bst(nodo_bst* p,
while (p != NULL and k != p -> _k) {
if (k _k)
p = p -> _izq;
else // p -> _k < k
p = p -> _der;
}
return p;
}
El algoritmo de insercin es tambin extremadamente simple y

se obtiene a partir de un razonamiento similar al utilizado para
desarrollar el algoritmo de bsqueda: si la nueva clave es
menor que la clave en la raz entonces el nuevo elemento se
ha de insertar (recursivamente) en el subrbol izquierda; si es
mayor, la insercin se realiza en el subrbol derecho.
El mtodo pblico INSERTA se apoya en otro mtodo privado de
clase llamado INSERTA _ EN _ BST. ste recibe un apuntador a la
raz del BST donde se debe insertar el par hk, vi y nos devuelve
un apuntador a la raz del BST resultante de la insercin. Si k
no aparece en el BST, se aade un nodo con el par hk, vi en el
lugar apropiado. Si k ya exista, entonces el mtodo modifica el
valor asociado a k, reemplazando el valor anterior por v.
Antes de pasar a la implementacin de las inserciones,

veamos la implementacin (trivial) de la constructora de la
clase nodo_bst:
Diccionario<Clave,Valor>::nodo_bst(const Clave& k,
Valor& v, nodo_bst* izq, nodo_bst* der) throw(error) :
_k(k), _v(v), _izq(izq), _der(der) {
}

void Diccionario::inserta(const Clave& k,
const Valor& v) throw(error) {
raiz = inserta_en_bst(raiz, k, v);
}
// implementacin recursiva
Diccionario<Clave,Valor>::nodo*
Diccionario<Clave,Valor>::inserta_en_bst(nodo_bst* p,
const Clave& k, const Valor& v) throw(error) {
if (p == NULL)
return new nodo_bst(k, v);
//
//
//
if
p != NULL, contina la insercin en el

subrbol apropiado o reemplaza el valor
asociado si p -> _k == k
(k _k)
p -> _izq = inserta_en_bst(p -> _izq, k, v);
else if (p -> _k < k)
p -> _der = inserta_en_bst(p -> _der, k, v);
else // p -> _k == k
p -> _v = v;
return p;
}
La versin iterativa es ms compleja, ya que adems de

localizar la hoja en la que se ha de realizar la insercin, deber
mantenerse un apuntador padre al que ser padre del nuevo
nodo.
// implementacin iterativa
Diccionario<Clave,Valor>::inserta_en_bst(nodo_bst* p,
// el BST est vaco
if (p == NULL)
return new nodo_bst(k, v);
// el BST no est vaco
nodo_bst* padre = NULL;
nodo_bst* p_orig = p;
// buscamos el punto de insercin
while (p != NULL and k != p -> _k) {
padre = p;
if (k _k)
p = p -> _izq;
else // p -> _k < k
p = p -> _der;
}
//
//
//
if
insertamos el nuevo nodo como hoja

o modificamos el valor asociado, si
ya haba un nodo con la clave k dada
(p == NULL) {
if (k < padre -> _k)
padre -> izq = new nodo_bst(k, v);
else // k > padre -> _k
padre -> der = new nodo_bst(k, v);
}
else // k == p -> _k
p -> _v = v;
return p_orig;
}
Slo nos queda por considerar la eliminacin de elementos en

BSTs. Si el elemento a eliminar se encuentra en un nodo cuyos
dos subrboles son vacos basta eliminar el nodo en cuestin.
Otro tanto sucede si el nodo x a eliminar slo tiene un subrbol
no vaco: basta hacer que la raz del subrbol no vaco quede
como hijo del padre de x.
El problema surge si hay que eliminar un nodo que contiene

dos subrboles no vacos. Podemos reformular el problema de
la siguiente forma: dados dos BSTs T1 y T2 tales que todas las
claves de T1 son menores que las claves de T2 obtener un
nuevo BST que contenga todas las claves: T = JUNTAR(T1 , T2 ).
Obviamente:
JUNTAR (T, )
=T
JUNTAR (, T )
=T
En particular, JUNTAR(, ) = .

void Diccionario<Clave,Valor>::elimina(
raiz = elimina_en_bst(raiz, k);
}
Diccionario<Clave,Valor>::elimina_en_bst(nodo_bst* p,
// la clave no est
if (p == NULL) return p;
if (k _k)
p -> _izq = elimina_en_bst(p -> _izq, k);
else if (p -> k < k)
p -> _der = elimina_en_bst(p -> _der, k);
else { // k == p -> k
nodo_bst* to_kill = p;
p = juntar(p -> _izq, p -> _der);
delete to_kill;
}
return p;
}
Sea z + la mayor clave de T1 . Puesto que es mayor que todas

las dems en T1 pero al mismo tiempo menor que cualquier
clave de T2 podemos construir T colocando un nodo raz que
contenga al elemento de clave z + , a T2 como subrbol derecho
y al resultado de eliminar z + de T1 llammosle T10 como
subrbol izquierdo. Adems puesto que z + es la mayor clave
de T1 el correspondiente nodo no tiene subrbol derecho, y es
el nodo ms a la derecha en T1 , lo que nos permite
desarrollar un procedimiento ad-hoc para eliminarlo.
T1
z+
T2
z

Diccionario<Clave,Valor>::juntar(nodo_bst* t1,
nodo_bst* t2) throw() {
//
//
if
if
si uno
vaco,
(t1 ==
(t2 ==
de los dos subrboles es

la implementacin es trivial
NULL) return t2;
NULL) return t1;
// t1 != NULL y tambin t2 != NULL

nodo_bst* z = reubica_max(t1);
z -> _der = t2;
return z;
// alternativa: z = reubica_min(t2);
//
z -> _izq = t1;
//
return z;
}
El mtodo privado REUBICA _ MAX recibe un apuntador p a la

raz de un BST T y nos devuelve un apuntador a la raz de un
nuevo BST T 0 . La raz de T 0 es el elemento mximo de T . El
subrbol derecho de T 0 es nulo y el subrbol izquierdo de T 0 es
el BST que se obtiene al eliminar el elemento mximo de T .
La nica dificultad estriba en tratar adecuadamente la
situacin en la que el elemento mximo del BST se encuentra
ya como raz del mismodicha situacin debe detectarse y en
ese caso el mtodo no debe hacer nada.
Diccionario<Clave,Valor>::reubica_max(
nodo_bst* p) throw() {
nodo_bst* padre = NULL;
nodo_bst* p_orig = p;
while (p -> _der != NULL) {
padre = p;
p = p -> _der;
}
if (padre != NULL) {
padre -> _der = p -> _izq;
p -> _izq = p_orig;
}
return p;
}
Un razonamiento anlogo nos lleva a una versin de JUNTAR

en la que se emplea la clave mnima z del rbol T2 para que
ocupe la raz del resultado, en el caso en que T1 y T2 no son
vacos.
Se ha evidenciado experimentalmente que conviene alternar
entre el predecesor z + y el sucesor z del nodo a eliminar en
los borrados (por ejemplo, mediante una decisin aleatoria o
con bit que va pasando alternativamente de 0 a 1 y de 1 a 0) y
no utilizar sistemticamente una de las versiones.
Un BST de n elementos puede ser equivalente a una lista,

pues puede contener un nodo sin hijos y n 1 con slo un hijo
(p.e. si insertamos una secuencia de n elementos con claves
crecientes en un BST inicialmente vaco). Un BST con estas
caractersticas tiene altura n. En caso peor, el coste de una
bsqueda, insercin o borrado en dicho rbol es (n). En
general, una bsqueda, insercin o borrado en un BST de
altura h tendr coste (h) en caso peor. Como funcin de n, la
altura de un rbol puede llegar a ser n y de ah que el coste de
las diversas operaciones es, en caso peor, (n).
Pero normalmente el coste de estas operaciones ser menor.

Supongamos que cualquier orden de insercin de los
elementos es equiprobable. Para bsquedas con xito
supondremos que buscamos cualquiera de las n claves con
probabilidad 1/n. Para bsquedas sin xito o inserciones
supondremos que finalizamos en cualquiera de las n + 1 hojas
con igual probabilidad.
El coste de una de estas operaciones va a ser proporcional al
nmero de comparaciones que habr que efectuar entre la
clave dada y las claves de los nodos examinados. Sea C(n) el
nmero medio de comparaciones y C(n; k) el nmero medio de
comparaciones si la raz est ocupada por la k-sima clave.
X
C(n) =
C(n; k) P[raz es k-sima] .
1kn
1 X
C(n; k)
n
1kn

k1
nk
1 X
1
0+
C(k 1) +
C(n k)
=1+
n
n
n
n
1kn
1 X
=1+ 2
(k C(k) + (n 1 k) C(n 1 k))
n
0k<n
2 X
k C(k).
=1+ 2
n
C(n) =
0k<n
Otra forma de plantear esto es calcular I(n), el valor medio de

la longitud de caminos internos (IPL). Dado un BST su longitud
de caminos internos es la suma de las distancias desde la raz
a cada uno de los nodos.
C(n) = 1 +
I(n)
n
La longitud media de caminos internos satisface la recurrencia

I(n) = n 1 +
2 X
I(k),
n
I(0) = 0.
(1)
0k<n
Esto es as porque cada nodo que no sea la raz contribuye al

IPL total 1 ms su contribucin al IPL del subrbol en que se
encuentre. Otra razn por la que resulta interesante estudiar el
IPL medio es porque el coste de construir un BST de tamao n
mediante n inserciones es proporcional al IPL.
Podemos asociar a cada ejecucin de Q UICK S ORT un BST

como sigue. En la raz se coloca el pivote de la fase inicial; los
subrboles izquierdo y derecho corresponden a las
ejecuciones recursivas de Q UICK S ORT sobre los subvectores a
la izquierda y a la derecha del pivote.
Consideremos un subrbol cualquiera de este BST. Todos los
elementos del subrbol, salvo la raz, son comparados con el
nodo raz durante la fase a la que corresponde ese subrbol. Y
recprocamente el pivote de una determinada fase ha sido
comparado con los elementos (pivotes) que son sus
antecesores en el rbol y ya no se comparar con ningn otro
pivote. Por lo tanto, el nmero de comparaciones en las que
interviene un cierto elemento no siendo el pivote es igual a su
distancia a la raz del BST. Por esta razn I(n) = Q(n).
Para resolver la recurrencia de I(n) (longitud de caminos

internos en BSTs) calculamos (n + 1)I(n + 1) nI(n):
(n + 1)I(n + 1) nI(n) = (n + 1)n n(n 1) + 2I(n)
= 2n + 2I(n);
(n + 1)I(n + 1) = 2n + (n + 2)I(n)
2(n 1)(n + 2)
n+2
2n
n+2
2n
+
I(n) =
+
+
I(n 1)
n+1
n+1
n+1
n(n + 1)
n
2(n 1)(n + 2)
2(n 2)(n + 2)
2n
n+2
=
+
+
+
I(n 2)
n+1
n(n + 1)
n(n 1)
n1
I(n + 1) =
i=k
X
ni
n+2
2n
+ 2(n + 2)
+
I(n k)
n+1
(n
i
+
1)(n
i
+
2)
n
k+1
i=1
i=n
X
2n
i
+ 2(n + 2)
n+1
(i
+
1)(i
+ 2)
i=1

X 2
1
= O(1) + 2(n + 2)
i+2
i+1
1in
1
2
+
+ Hn 2)
n+2
n+1
= 2nHn 4n + 4Hn + O(1),
= O(1) + 2(n + 2)(
P
donde Hn = 1in 1/i.
Puesto que Hn = ln n + O(1) se sigue que
I(n) = Q(n) = 2n ln n + O(n)
= 1,386 . . . n log2 n + O(n)
y que C(n) = 2 ln n + O(1).
Los BSTs permiten otras varias operaciones siendo los

algoritmos correspondientes simples y con costes (promedio)
razonables. Algunas operaciones como las de bsqueda o
borrado por rango (e.g. busca el 17o elemento) o de clculo del
rango de un elemento dado requieren una ligera modificacin
de la implementacin estndar, de tal forma que cada nodo
contenga informacin relativa a tamao del subrbol en l
enraizado. Concluimos esta parte con un ejemplo concreto:
dadas dos claves k1 y k2 , k1 < k2 se precisa una operacin que
devuelve una lista ordenada de todos los elementos cuya clave
k est comprendida entre las dos dadas, esto es, k1 k k2 .
Si el BST es vaco, la lista a devolver es tambin vaca.

Supongamos que el BST no es vaco y que la clave en la raz
es k. Si k < k1 entonces todas las claves buscadas deben
encontrarse, si las hay, en el subrbol derecho. Anlogamente,
si k2 < k se proseguir la bsqueda recursivamente en el
subrbol izquierdo. Finalmente, si k1 k k2 entonces puede
haber claves que caen dentro del intervalo tanto en el subrbol
izquierdo como en el derecho. Para respetar el orden creciente
en la lista, deber buscarse recursivamente a la izquierda,
luego listar la raz y finalmente buscarse recursivamente a la
derecha.
// El mtodo en_rango se ha de declarar como

// mtodo pblico de la clase Diccionario.
// Dicho mtodo usa a otro auxiliar,
// en_rango_en_bst, que se habra declarado
// como mtodo privado de clase (static).
void Diccionario<Clave,Valor>::en_rango(
const Clave& k1, const Clave& k2,
list<pair<Clave,Valor> >& result) const throw(error) {
en_rango_en_bst(raiz, k1, k2, result);
}
void Diccionario<Clave,Valor>::en_rango_en_bst(nodo_bst* p,
const Clave& k1, const Clave& k2,
list<pair<Clave,Valor> >& result) const throw(error) {
if (p == NULL) return;
if (k1 <= p -> _k)
en_rango_en_bst(p -> _izq, k1, k2, result);
if (k1 <= p -> _k and p -> _k <= k2)
result.push_back(make_pair(p -> _k, p -> _v));
if (k <= p -> _k)
en_rango_en_bst(p -> _der, k1, k2, result);
}
Divide y vencers
Tablas de Hash
Colas de prioridad
Grafos y Recorridos
rboles equilibrados
El problema de los BSTs estndar es que, como resultado de

ciertas secuencias de inserciones y/o borrados, pueden quedar
muy desequilibrados.
En caso peor la altura de un BST de tamao n es (n) y en
consecuencia el coste en caso peor de las operaciones de
bsqueda, insercin y borrado es (n).
A fin de evitar este problema, se han propuesto diversas
soluciones; la ms antigua y una de las ms elegantes y
sencillas, es el equilibrado en altura, propuesto en 1962 por
Adelson-Velskii y Landis.
Los rboles de bsqueda resultantes se denominan AVLs en
honor a sus inventores.
Definicin
Un AVL T es un rbol binario de bsqueda tal que o es vaco o
bien cumple que
1
Los subrboles izquierdo y derecho, L y R,

respectivamente, son AVLs.
Las alturas de L y de R difieren a lo sumo en una unidad:

|altura(L) altura(R)| 1
La naturaleza recursiva de la definicin anterior garantiza que

la condicin de equilibrio se cumple en cada nodo x de un AVL.
Si denotamos bal(x) la diferencia entre las alturas de los
subrboles izquierdo y derecho de un nodo cualquiera x
tendremos que bal(x) {1, 0, +1}.
Por otro lado todo AVL es un rbol binario de bsqueda, por lo
que el algoritmo de bsqueda en AVLs es idntico al de BSTs,
y un recorrido en inorden de un AVL visitar todos sus
elementos en orden creciente de claves.
{enero, febrero, marzo, abril, mayo, junio, julio, agosto, septiembre, octubre
noviembre, diciembre}
marzo
febrero
octurbre
agosto
abril
junio
enero
diciembre
julio
mayo
septiembre
noviembre
Lema
La altura h(T ) de un AVL de tamao n es (log n).
Demostracin. Puesto que el AVL es un rbol binario se
cumple que h(T ) dlog2 (n + 1)e, es decir, h(T ) (log n).
Ahora vamos a demostrar que h(T ) O(log n).
Sea Nh el mnimo nmero de nodos necesario para construir
un AVL de altura h. Claramente N0 = 0 y N1 = 1. El AVL ms
desequilibrado posible de altura h > 1 se consigue poniendo
un subrbol, digamos el izquierdo, de altura h 1 empleando el
mnimo posible de nodos Nh1 y otro subrbol, el derecho, que
tendr altura h 2 (pero no puede tener menos!) en el que
pondremos tambin el mnimo posible de nodos, Nh2 . Por
tanto,
Nh = 1 + Nh1 + Nh2
Veamos algunos valores de la secuencia {Nh }h0 :

0, 1, 2, 4, 7, 12, 20, 33, 54, 88, . . .
La similitud con la secuencia de los nmeros de Fibonacci
llama rpidamente nuestra atencin y no es casual: puesto que
F0 = 0, F1 = 1, Fn = Fn1 + Fn2 se cumple que Nh = Fh+1 1
para toda h 0. En efecto, N0 = F1 1 = 1 1 = 0 y
Nh = 1 + Nh1 + Nh2 = 1 + (Fh 1) + (Fh1 1) = Fh+1 1
El nmero n-simo de Fibonacci cumple:

n
1
,
Fn = +
5 2
donde = (1 + 5)/2 1,61803 . . . es la razn urea.
Consideremos ahora un AVL de tamao n y altura h. Entonces

n Nh por definicin y
h+1 3
n Fh+1 1
2
5
Luego,
3 5
(n + )
h
2
Tomando logaritmos en base , y simplificando

h log n + O(1) = 1,44 log2 n + O(1)
El lema queda demostrado.
Del lema anterior deducimos que el coste de cualquier

bsqueda en un AVL de tamao n ser, incluso en caso peor,
O(log n).
El problema reside en cmo conseguir que se cumpla la
condicin de equilibrio en cada uno de los nodos del AVL tras
una insercin o un borrado.
La idea es que ambos algoritmos actan igual que los
correspondientes en BSTs, pero cada uno de los nodos en el
camino que va de la raz al punto de insercin (o borrado) debe
ser comprobado para verificar que contina cumpliendo la
condicin de balance y si no es as hacer algo al efecto.
En primer lugar nos damos cuenta de que ser necesario que
cada nodo almacene informacin sobre su altura (o su
balance), para evitar cmputos demasiado costosos.

class Diccionario {
public:
...
void buscar(const Clave& k,
void inserta(const Clave& k,
...
private:
struct nodo_avl {
Clave _k;
Valor _v;
int _alt;
nodo_avl* _izq;
nodo_avl* _der;
// constructora de la clase nodo_avl
nodo_avl(const Clave& k, const Valor& v,
int alt = 1,
nodo_avl* izq = NULL,
nodo_avl* der = NULL);
};
nodo_avl* raiz;
...
static int altura(nodo_avl* p) throw();
static void actualizar_altura(nodo_avl* p) throw();
};
int max(int x, int y) {

return x > y ?
x : y;
}
static int Diccionario<Clave,Valor>::altura(
nodo_avl* p) throw() {
if (p == NULL)
return 0;
else
return p -> _alt;
}
static void Diccionario<Clave,Valor>::actualizar_altura(
nodo_avl* p) throw() {
p -> _alt = 1 + max(altura(p -> _izq), altura(p -> _der));
}
Para reestablecer el balance en un nodo que ya no cumpla la

condicin de balance se utilizan rotaciones.
La figura muestra las rotaciones ms simples. Obsrvese que
si el rbol de la izquierda es un BST (A < x < B < y < C)
entonces el de la derecha tambin lo es, y viceversa.
y
C
A
B
Supongamos un subrbol de un AVL con raz y en el que

estamos haciendo la insercin de una clave k tal que k < x < y
y que finalizado el proceso de insercin recursiva se produce
un desequilibrio en y.
Si C tiene altura h entonces el subrbol enraizado en x ha de
tener altura h altura h + 1. Si la altura de x fuera h entonces
la insercin de la nueva clave k no podra provocar el
desequilibrio en y, de manera que vamos a suponer que la
altura de x es h + 1.
Razonando de manera parecida llegamos a la conclusin de

que la altura de A tiene que ser h. As pues la altura de y,
previa a la insercin era h + 2. Como consecuencia de la
insercin vamos a suponer que la altura del subrbol A se
incrementa, de manera que el nuevo subrbol A0 tiene altura
h + 1. Si suponemos que x mantiene la condicin de AVL tras
la insercin (pero y no) eso nos lleva a concluir que B tambin
tena altura h.
Tras la insercin el subrbol enraizado en x pasa a tener altura
h + 2 de manera que bal(y) = +2!
Antes:
y
x
C
h+1
A
Despues:
y
h+2
A
h+1
LL
x
y
h+1
h+1
A
B
Al aplicar la rotacin sobre el nodo y, se preserva la propiedad

de BST y adems se reestablece la propiedad de AVL. Por
hiptesis, A0 , B y C son AVLs. Tras la rotacin la altura de y es
h + 1 y su balance 0, y la altura de x pasa a ser h + 2 y su
balance 0.
No slo hemos solventado el problema de desequilibrio en y: el
subrbol donde hemos aplicado la insercin es un AVL y tiene
la misma altura que el subrbol antes de hacer la insercin, de
manera que ninguno de los antecesores de y en el AVL va a
estar desbalanceado.
A la rotacin que hemos empleado se le suele denominar LL
(left-left).
Un anlisis anlogo revela que si la clave insertada k cumple

x < y < k y se produce un desbalanceo en el nodo x, entonces
podemos reestablecer el equilibrio aplicando una rotacin RR
(right-right) sobre el nodo x. La rotacin RR es la simtrica de
la rotacin LL.
RR
y
x
y
A
h
h+2
h
B
h+1
h+1
C
A
h+1
Analicemos ahora el caso de un subrbol de un AVL con raz y

en el que estamos haciendo la insercin de una clave k, pero
esta vez x < k < y y que finalizado el proceso de insercin
recursiva se produce un desequilibrio en y.
Si C tiene altura h entonces el subrbol enraizado en x ha de
tener altura h + 1, la altura de B ha de ser h (aqu razonamos
igual que cuando hicimos el anlisis de la situacin LL).
Como consecuencia de la insercin vamos a suponer que la
altura del subrbol B se incrementa, de manera que el nuevo
subrbol B 0 tiene altura h + 1. Si suponemos que x mantiene la
condicin de AVL tras la insercin (pero y no) eso nos lleva a
concluir que A tambin tena altura h.
Tras la insercin el subrbol enraizado en x pasa a tener altura
h + 2 de manera que bal(y) = +2!
Si aplicamos la rotacin simple LL sobre el nodo y, se preserva

la propiedad de BST pero no se reestablece la propiedad de
AVL. Por hiptesis, A, B 0 y C son AVLs. Pero tras la rotacin LL
la altura de y es h + 2 y su balance +1, y la altura de x pasa a
ser h + 3 y su balance 2!
LL no sirve
y
x
C
y
A
h+1
A
h+1
h
h+1
h+2
Vamos a tener que pensar alguna otra cosa y hacer un anlisis

ms fino.
Vamos a suponer que la raz del subrbol B 0 es z y que tiene

subrboles B1 y B2 , ambos AVLs. Puesto que B 0 tiene altura
h + 1 y es un AVL, al menos uno de los dos subrboles Bi tiene
altura h y el otro Bj tiene altura h h 1.
Si aplicamos una rotacin que lleva a z a la raz entonces x es
la raz de su subrbol izquierdo y sus hijos son A y B1 , y y es
la raz de su subrbol derecho y sus hijos son B2 y C.
LR
y
x
C
h+2
y
h+1
<
_ h+1
z
h
B1
B2
h+2
h+1
B1
B2
<
_h
Ntese que antes de la rotacin el inorden era

A < x < B1 < z < B2 < y < C, exactamente igual que tras la
rotacin, esto, este nuevo tipo de rotacin tambin preserva la
propiedad de BST.
Al aplicar la rotacin sobre el nodo y, se preserva la propiedad

de BST y adems se reestablece la propiedad de AVL. Por
hiptesis, A, B y C son AVLs. Tras la rotacin la altura de x es
h + 1 y su balance 0 +1, la altura de y es h + 1 y su balance 0
1, y la altura de z pasa a ser h + 2 y su balance 0.
Igual que con las rotaciones simples LL y RR, no slo
arreglamos el problema de desequilibrio en y: el subrbol
donde hemos aplicado la insercin es un AVL y tiene la misma
altura que el subrbol antes de hacer la insercin, de manera
que ninguno de los antecesores de y en el AVL va a estar
desbalanceado.
A esta nueva rotacin se le denomina rotacin doble LR
(left-right).
Para la situacin en que una clave se inserta a la derecha y

luego hacia la izquierda, el desequilibrio que se pudiera
producir se corrige mediante una rotacin RL, que es
completamente anloga a la LR, cambiando derecha por
izquierda y viceversa.
RL
x
z
y
h+2
h
C
h+1
B1
h+1
<
_ h+1
B2
<
_h
A
h+2
B1
B2
Las rotaciones dobles (LR y RL) se denominan as porque

podemos descomponerlas como una secuencia de dos
rotaciones simples. Por ejemplo la rotacin doble LR sobre el
nodo y consiste en primero aplicar una rotacin RR sobre x y a
continuacin una rotacin LL sobre y (su hijo izquierdo ha
pasado a ser z y no x).
RR(x)
y
z
A
h+2
B1
h+2
B2
<
_ h1
B2
B1
LL(y)
h+2
y
h+1
B1
B2
<
_ h1
De manera similar, una rotacin RL se compone de una

rotacin LL seguida de una rotacin RR.
LL(y)
x
x
y
y
C
B1
B2
h+2
<
_h
B1
h+2
B2
RR(x)
h+2
<
_h
A
<
_h
B1
h+1
B2
Ejemplo de los meses del ao en un AVL:

enero 2
febrero
RR
febrero
marzo
enero
marzo
+{enero, febrero, marzo}

febrero
+2
abril
enero
marzo
junio +1
0 agosto
+1
mayo
julio
+ {abril, mayo, junio, julio, agosto}
LR
1
febrero
0
abril
marzo +1
agosto
0
junio +1
enero
julio
mayo

2
febrero
0
abril
agosto
marzo
0
junio +1
enero
julio
mayo
septiembre
0
+1
octubre
+ {septiembre, octubre}
RL
febrero
0
abril
marzo 0
agosto
0
junio +1
enero
julio
0 mayo
octubre
septiembre

febrero
0
abril
marzo 1
agosto
junio
enero
julio
+1
octubre
+1
mayo
septiembre
0
noviembre
+ {noviembre}
RR
marzo 0
octubre
febrero
0 agosto
abril
junio +1
enero
julio
octubre
abril
diciembre
junio +1
+1
enero
julio
+ {diciembre}
septiembre
+1
febrero
1 agosto
noviembre
marzo
+1
mayo
+1
mayo
+1
noviembre
septiembre
De nuestro anlisis previo podemos establecer los siguientes

hechos y sus consecuencias:
1
Una rotacin simple o doble slo involucra la modificacin

de unos pocos apuntadores y actualizaciones de alturas, y
su coste es por tanto (1), independiente de la talla del
rbol.
En una insercin en un AVL slo habr que efectuarse a lo

sumo una rotacin (simple o doble) para reestablecer el
equilibrio del AVL. Dicha rotacin se aplica, en su caso, en
uno de los nodos en el camino entre la raz y el punto de
insercin.
El coste en caso peor de una insercin en un AVL es

(log n).

class Diccionario {
public:
...
private:
struct nodo_avl {
...
};
nodo_avl* raiz;
...
static nodo_avl* inserta_en_avl(nodo_avl* p,
const Clave& k, const Valor& v) throw(error);
static nodo_avl* rotacionLL(nodo_avl* p) throw();
static nodo_avl* rotacionLR(nodo_avl* p) throw();
static nodo_avl* rotacionRL(nodo_avl* p) throw();
static nodo_avl* rotacionRR(nodo_avl* p) throw();
...
};

Diccionario<Clave,Valor>::nodo_avl*
Diccionario<Clave,Valor>::rotacionLL(nodo_avl* p)
throw() {
nodo_avl* q = p -> _izq;
p -> _izq = q -> _der;
q -> _der = p;
actualiza_altura(p);
actualiza_altura(q);
return q;
}
Diccionario<Clave,Valor>::rotacionRR(nodo_avl* p)
throw() {
nodo_avl* q = p -> _der;
p -> _der = q -> _izq;
q -> _izq = p;
actualiza_altura(q);
return q;
}

Diccionario<Clave,Valor>::rotacionLR(nodo_avl* p)
throw() {
p -> _izq = rotacionRR(p -> _izq);
return rotacionLL(p);
}
Diccionario<Clave,Valor>::rotacionRL(nodo_avl* p)
throw() {
p -> _der = rotacionLL(p -> _der);
return rotacionRR(p);
}

Diccionario<Clave,Valor>::inserta_en_avl(nodo_avl* p,
if (p == NULL)
return new nodo_avl(k, v);
if (k _k) {
p -> _izq = inserta_en_avl(p -> _izq, k, v);
// comprobamos si hay desequilibrio en p
// y rotamos si es necesario
if (altura(p -> _izq) - altura(p -> _der) == 2) {
// p -> _izq no puede ser vaco
if (k _izq -> _k) // caso LL
p = rotacionLL(p);
else // caso LR
p = rotacionLR(p);
}
}
else if (p -> _k < k) { // analogo al caso anterior ...
p -> _der = inserta_en_avl(p -> _der, k, v);
if (altura(p -> _der) - altura(p -> _izq) == 2) {
if (p -> _der -> _k < k) // caso RR
p = rotacionRR(p);
else // caso RL
p = rotacionRL(p);
}
}
else // p -> _k == k
p -> _v = v;
return p;
}
Si bien resulta posible escribir una versin iterativa del

algoritmo de insercin, resulta complicada ya que una vez
efectuada la insercin del nuevo nodo en la hoja que
corresponde deberemos deshacer el camino hasta la raz para
detectar si en alguno de los nodos del camino se produce un
desequilibrio y entonces aplicar la rotacin correspondiente.
Este deshacer el camino ocurre de manera natural con la
recursividad, a la vuelta de cada llamada recursiva
comprobamos si en el nodo desde el que se hace la llamada
recursiva hay o no desequilibrio al terminar la insercin.
Para una versin iterativa necesitaramos que cada nodo
contuviese un apuntador explcito a su padre o bien tendremos
que almacenar la secuencia de nodos visitados durante la
bajada en una pila, y despus ir desapilando uno a uno para
deshacer el camino.
El algoritmo de borrado en AVLs se fundamenta en las mismas

ideas, si bien el anlisis de qu rotacin aplicar en cada caso
es un poco ms complejo.
Baste decir que el coste en caso peor de un borrado en un AVL
es (log n). Los desequilibrios se solucionan aplicando
rotaciones simples o dobles, pero a diferencia de lo que sucede
con las inserciones, podemos tener que aplicar varias. No
obstante, todas las rotaciones (de coste (1)) se aplican a lo
sumo una vez sobre cada uno de los nodos del camino desde
la raz hasta el punto de borrado, y como slo hay O(log n) de
stos, el coste es logartmico en caso peor.
El algoritmo de borrado en AVLs es relativamente ms
complejo que el de insercin, y la versin iterativa an ms.
En las siguientes transparencias se muestra el cdigo del
algoritmo de borrado, en su versin recursiva, sin ms
comentarios.

Diccionario<Clave,Valor>::elimina_en_avl(nodo_avl* p,
if (p == NULL) return p;
if (k _k) {
p -> _izq = elimina_en_avl(p -> _izq, k);
// p -> _der no puede ser vaco
if (altura(p -> _der -> _izq)
- altura(p -> _der -> _der) == 1)
p = rotacionRL(p);
else
p = rotacionRR(p);
}
}
else if (p -> _k < k) { // analogo al caso anterior ...
p -> _der = elimina_en_avl(p -> _der, k);
if (altura(p -> _izq) - altura(p -> _der) == 2) {
if (altura(p -> _izq -> _der)
- altura(p -> _der -> _izq) == 1)
p = rotacionLR(p);
else
p = rotacionLL(p);
}
}
else { // p -> _k == k
nodo_avl* to_kill = p;
p = juntar(p -> _izq, p -> _der);
delete to_kill;
}
return p;
}

Diccionario<Clave,Valor>::juntar(nodo_avl* t1,
nodo_avl* t2) throw() {
//
//
if
if
si uno
vaco,
(t1 ==
(t2 ==
de los dos subrboles es

la implementacin es trivial
NULL) return t2;
NULL) return t1;
// t1 != NULL y tambin t2 != NULL

nodo_alv* z;
elimina_min(t2, z);
z -> _izq = t1;
z -> _der = t2;
actualiza_altura(z);
return z;
}

Diccionario<Clave,Valor>::elimina_min(
nodo_avl*& p, nod_avl*& z) throw() {
if (p -> _izq != NULL) {
elimina_min(p -> _izq, z);
// p -> _der no puede ser vaco
if (altura(p -> _der -> _izq)
- altura(p -> _der -> _der) == 1)
p = rotacionRL(p);
else
p = rotacionRR(p);
}
} else {
z = p;
p = p -> _der;
}
}
Divide y vencers
Tablas de Hash
Colas de prioridad
Grafos y Recorridos
Tablas de dispersin (hash)
Una tabla de dispersin (ing: hash table) permite almacenar un

conjunto de elementos (o pares clave-valor) mediante una
funcin de dispersin h que va del conjunto de claves al
conjunto de ndices o posiciones de la tabla (p.e. 0..M 1).
Idealmente la funcin de dispersin h hara corresponder a
cada uno de los n elementos (de hecho a sus claves) que
queremos almacenar una posicin distinta. Obviamente, esto
no ser posible en general y a claves distintas les
corresponder la misma posicin de la tabla.
Pero si la funcin de dispersin dispersa eficazmente las

claves, el esquema seguir siendo til, ya que la probabilidad
de que el diccionario a representar mediante la tabla de hash
contenga muchas claves con igual valor de h ser pequea.
Dadas dos claves x e y distintas, se dice que x e y son
sinnimos, o que colisionan, si h(x) = h(y).
El problema bsico de la implementacin de un diccionario
mediante una tabla de hash consistir en la definicin de una
estrategia de resolucin de colisiones.
template <typename T> class Hash {

public:
int operator()(const T& x) const throw();
};
template <typename Clave, typename Valor,
template <typename> class HashFunct = Hash>
class Diccionario {
public:
...
void busca(const Clave& k,
void inserta(const Clave& k, const Valor& v) throw(error);
...
private:
struct nodo {
Clave _k;
Valor _v;
...
};
nat _M; // tamao de la tabla
nat _n; // nm. de elementos en la tabla
double _alfa_max; // factor de carga
// direccionamiento abierto
nodo* _Thash; // tabla con los pares <clave,valor>
// separate chaining
// nodo** _Thash; // tabla de punteros a nodo
static int hash(const Clave& k) throw() {
HashFunct<Clave> h;
return h(k) % _M;
}
};
Funciones de hash
Una buena funcin de hash debe tener las siguientes

propiedades:
1
Debe ser fcil de calcular
Debe dispersar de manera razonablemente uniforme el

espacio de las claves, es decir, si dividimos el conjunto de
todas las claves en grupos de sinnimos, todos los grupos
deben contener aproximadamente el mismo nmero de
claves.
Debe enviar a posiciones distantes a claves que son

similares.
La construccin de buenas funciones de hash no es fcil y

requiere conocimientos muy slidos de varias ramas de las
matemticas. Est fuertemente relacionada con la
construccin de generadores de nmeros pseudoaleatorios.
Como regla general da buenos resultados calcular un nmero
entero positivo a partir de la representacin binaria de la clave
(p.e. sumando los bytes que la componen) y tomar mdulo M ,
el tamao de la tabla. Se recomienda que M sea un nmero
primo.
La clase Hash<T> define el operador () de manera que si h
es un objeto de la clase Hash<T> y x es un objeto de la clase
T, podemos aplicar h(x). Esto nos devolver un nmero
entero. La operacin privada hash de la clase Diccionario
calcular el mdulo mediante h(x) % _M de manera que
obtengamos un ndice vlido de la tabla, entre 0 y _M - 1.
// especializacin del template para T = string

template <> class Hash<string> {
public:
int operator()(const string& x) const throw() {
int s = 0;
for (int i = 0; i < x.length(); ++i)
s = s * 37 + x[i];
return s;
};
// especializacin del template para T = int
template <> class Hash<int> {
static long const MULT = 31415926;
public:
int operator()(const int& x) const throw() {
long y = ((x * x * MULT) << 20) >> 4;
return y;
}
};
Otras funciones de hash ms sofisticadas emplean sumas

ponderadas o transformaciones no lineales (p.e. elevan al
cuadrado el nmero representado por los k bytes centrales de
la clave).
Resolucin de colisiones
Existen dos grandes familias de estrategias de resolucin de

colisiones. Por razones histricas, que no lgicas, se utilizan
los trminos dispersin abierta (ing: open hashing) y
direccionamiento abierto (ing: open addressing).
Estudiaremos dos ejemplos representativos: tablas abiertas
con sinnimos encadenados (ing: separate chaining) y sondeo
lineal (ing: linear probing).
Sinnimos encadenados
En las tablas con sinnimos encadenados cada entrada de la
tabla da acceso a una lista enlazada de sinnimos.
class Diccionario {
...
private:
struct nodo {
Clave _k;
Valor _v;
nodo* _sig;
// constructora de la clase nodo
nodo(const Clave& k, const Valor& v,
nodo* sig = NULL);
};
nodo** _Thash; // tabla de punteros a nodo
int _M;
// tamao de la tabla
int _n;
// numero de elementos
nodo* busca_sep_chain(const Clave& k) const throw();
void inserta_sep_chain(const Clave& k,
void elimina_sep_chain(const Clave& k) throw();
};
M = 13
X = { 0, 4, 6, 10, 12, 13, 17, 19, 23, 25, 30}
h (x) = x mod M
13
30
17
19
23
10
25
12
1
2
3
4
5
6
7
8
9
10
11
12
Para la insercin, se accede a la lista correspondiente

mediante la funcin de hash, y se recorre para determinar si ya
exista o no un elemento con la clave dada. En el primer caso,
se modifica la informacin asociada; en el segundo se aade
un nuevo nodo a la lista con el nuevo elemento.
Puesto que estas listas de sinnimos contienen por lo general
pocos elementos lo ms efectivo es efectuar las inserciones
por el inicio (no hace falta usar fantasmas, cierre circular, etc.).
Existen variantes en que las listas de sinnimos estn
ordenadas o se sustituyen por rboles de bsqueda, pero no
comportan una ventaja real en trminos prcticos (el coste
asinttico terico es mejor, pero el criterio no es efectivo ya que
el nmero de elementos involucrado es pequeo).
La bsqueda es tambin simple: se accede a la lista apropiada

mediante la funcin de hash y se realiza un recorrido
secuencial de la lista hasta que se encuentra un nodo con la
clave dada o la lista se ha examinado sin xito.

template <typename> class HashFunct>
void Diccionario<Clave,Valor,HashFunct>::inserta(const Clave& k,
const Valor& v) throw(error) {
if (_n / _M > _alfa_max)
// la tabla est demasiado llena ... enviar un error
// o redimensionar
inserta_sep_chain(k, v);
}
void Diccionario<Clave,Valor,HashFunct>::inserta_sep_chain(
int i = hash(k);
nodo* p = _Thash[i];
// buscamos en la lista de sinnimos
while (p != NULL and p -> _k != k)
p = p -> _sig;
// lo insertamos al principio
// si no estaba
if (p == NULL) {
_Thash[i] = new nodo(k, v, _Thash[i]);
++_n;
}
else
p -> _v = v;
}

void Diccionario<Clave,Valor,HashFunct>::busca(const Clave& k,
nodo* p = buscar_sep_chain(k);
if (p == NULL)
esta = false;
else {
esta = true;
v = p -> _v;
}
}
Diccionario<Clave,Valor,HashFunct>::nodo*
Diccionario<Clave,Valor,HashFunct>::busca_sep_chain(const
Clave& k) const throw() {
int i = hash(k);
// buscamos en su lista de sinnimos
while (p != NULL and p -> _k != k)
p = p -> _sig;
return p;
}

void Diccionario<Clave,Valor, HashFunct>::elimina(const
Clave& k) throw() {
eliminar_sep_chain(k);
}
void Diccionario<Clave,Valor,HashFunct>::eliminar_sep_chain
(const Clave& k) throw() {
int i = hash(k);
nodo* ant = NULL; // apuntara al anterior de p
// buscamos en su lista de sinnimos
while (p != NULL and p -> _k != k) {
ant = p;
p = p -> _sig;
}
//
//
//
if
}
}
si p != NULL, lo quitamos de la
lista teniendo en cuenta que puede
ser el primero
(p != NULL) {
--_n;
if (ant != NULL)
ant -> _sig = p -> _sig;
else
_Thash[i] = p -> _sig;
delete p;
Sea n el nmero de elementos almacenados en la tabla con

encadenamiento de sinnimos. En promedio, cada lista tendr
= n/M elementos y el coste de bsquedas (con y sin xito),
de inserciones y borrados ser proporcional a . Si es un
valor razonablemente pequeo entonces podemos considerar
que el coste promedio de todas las operaciones sobre la tabla
de hash es (1), ya que es constante.
Al valor se le denomina factor de carga (ing: load factor). Otra

variantes de hash abierto almacenan los sinnimos en una
zona particular de la propia tabla, la llamada zona de
excedentes (ing: cellar). Las posiciones de esta zona no son
direccionables, es decir, la funcin de hash nunca toma sus
valores.
Direccionamiento abierto
En las estrategias de direccionamiento abierto los sinnimos

se almacenan en la tabla de hash, en la zona de
direccionamiento. Bsicamente, tanto en bsquedas como en
inserciones se realiza una secuencia de sondeos que
comienza en la posicin i0 = h(k) y a partir de ah contina en
i1 , i2 , . . . hasta que encontramos una posicin ocupada por un
elemento cuya clave es k (bsqueda con xito), una posicin
libre (bsqueda sin xito, insercin) o hemos explorado la tabla
en su totalidad. Las distintas estrategias varan segn la
secuencia de sondeos que realizan. La ms sencilla de todas
es el sondeo lineal: i1 = i0 + 1, i2 = i1 + 1, . . ., realizndose los
incrementos mdulo M .
Sondeo lineal
class Diccionario {
...
private:
struct nodo {
Clave _k;
Valor _v;
bool _libre;
// constructora de la clase nodo
nodo(const Clave& k, const Valor& v, bool libre = true);
};
nodo* _Thash; // tabla de nodos
int _M;
// tamao de la tabla
int _n;
// numero de elementos
int busca_linear_probing(const Clave& k) const throw();

void inserta_linear_probing(const Clave& k,
void elimina_linear_probing(const Clave& k) throw();
};
M = 13
X = { 0, 4, 6, 10, 12, 13, 17, 19, 23, 25, 30}
h (x) = x mod M
(incremento 1)
ocupado
13
ocupado
13
ocupado
libre
25
ocupado
libre
libre
ocupado
ocupado
17
ocupado
17
ocupado
ocupado
ocupado
19
ocupado
19
ocupado
libre
30
ocupado
libre
5
6
10
10
11
12
12
+ {0, 4, 6, 10, 12}
ocupado
libre
10
10
ocupado
10
10
ocupado
11
23
ocupado
11
23
ocupado
12
ocupado
12
12
ocupado
12
+ {13, 17, 19, 23}
+ {25, 30}
// Solo se invoca si hay al menos un sitio

// no ocupado en la tabla: _n < _M
void
Diccionario<Clave,Valor,HashFunct>::inserta_linear_probing(
int i = hash(k);
while (not _Thash[i]._libre and _Thash[i]._k != k)
i = (i + 1) % _M;
}
_Thash[i]._k = k; _Thash[i]._v = v;
if (_Thash[i]._libre) ++_n;
_Thash[i]._libre = false;
}

int Diccionario<Clave,Valor,HashFunct>::busca(
const Clave& k,
int i = busca_linear_probing(k);
if (not _Thash[i]._libre and _Thash[i]._k == k) {
esta = true;
v = _Thash[i]. _v;
}
else
esta = false;
}
int Diccionario<Clave,Valor,HashFunct>::busca_linear_probing(
const Clave& k) const throw() {
int i = hash(k);
int vistos = 0;
//
//
//
//
para asegurarnoss una pasada,

no ms; es inncesario si
n < _M ya que entonces habr
una posicin i tal que _libre == true
while (not _Thash[i]._libre and _Thash[i]._k != k

and vistos < _M) {
++vistos;
i = (i + 1) % _M;
}
return i;
}
El borrado en tablas de direccionamiento abierto es algo ms

complicado. No basta con marcar la posicin correspondiente
como libre ya que una bsqueda posterior podra no hallar el
elemento buscado aunque ste se encontrase en la tabla. Se
ha de recorrer los elementos que siguen al que se borra en el
mismo clster desplazando al lugar desocupado a todo
elemento cuya posicin inicial de hash preceda o sea igual a la
posicin desocupada. Para ello necesitamos la funcin
displ(j, i) que nos da la distancia entre las posiciones j e i en
el orden cclico: si j > i hay que dar la vuelta pasando por la
posicin _M 1 y regresando a la posicin 0.
int displ(j, i, M) {
if (i >= j)
return i - j;
else
return M + (i - j);
}
// asumimos para simplificar que _n < _M

int Diccionario<Clave,Valor,HashFunct>::elimina_linear_probing(
const Clave& k) const throw() {
int i = busca_linear_probing(k);
if (not _Thash[i]._libre) {
// _Thash[i] es el elemento que se quiere eliminar
int free = i; i = (i + 1) % _M; int d = 1;
while (not _Thash[i]._libre) {
int i_home = hash(_Thash[i]._k);
if (displ(i_home, i, _M) >= d) {
_Thash[free] = _Thash[i]; free = i; d = 0;
}
i = (i + 1) % _M; ++d;
}
_Thash[free]._libre = true; --_n;
}
}
El sondeo lineal ofrece algunas ventajas ya que los sinnimos

tienden a encontrarse en posiciones consecutivas, lo que
resulta ventajoso en implementaciones sobre memoria externa.
Generalmente se usara junto a alguna tcnica de bucketing:
cada posicin de la tabla es capaz de albergar b > 1 elementos.
Por otra parte tiene algunas serias desventajas y su
rendimiento es especialmente sensible al factor de carga
= n/M .
Si es prximo a 1 (tabla llena o casi llena) el rendimiento ser

muy pobre. Si < 1 el coste de las bsquedas con xito (y
modificaciones) ser proporcional a

1
1
1+
2
1
y el de bsquedas sin xito e inserciones ser proporcional a

1
1
1+
.
2
(1 )2
Un fenmeno indeseable que se acenta cuando es prximo

a 1 es el apiamiento (ing: clustering). Muchos elementos no
pueden ocupar su posicin preferida al estar ocupada por
otro elemento que no tiene porqu ser un sinnimo (invasor).
Grupos de sinnimos ms o menos dispersos acaban
fundindose en grandes clusters y cuando buscamos una
cierta clave tenemos que examinar no slo sus sinnimos sino
un buen nmero de claves que no tienen relacin alguna con la
clave buscada.
Redimensionamiento
Muchos lenguajes de programacin permiten crear tablas

fijando su tamao en tiempo de ejecucin. Entonces es posible
utilizar la llamada tcnica de redimensionamiento (ing:
resizing). Si el factor de carga es muy alto, superando un cierto
valores umbral, se reclama a la memoria dinmica una tabla
cuyo tamao es aproximadamente el doble del tamao de la
tabla en curso y se reinserta toda la informacin de la tabla en
curso sobre la nueva tabla.
Para ello se recorre secuencialmente la tabla en curso y cada

uno de los elementos presentes se inserta por el procedimiento
habitual en la nueva tabla, usando una funcin de hash distinta,
obviamente. La operacin de redimensionamiento requiere
tiempo proporcional al tamao de la tabla en curso (y por tanto
(n)); pero hay que hacerla slo muy de vez en cuando. El
redimensionamiento permite que el diccionario crezca sin
lmites prefijados, garantizando un buen rendimiento de todas
las operaciones y sin desperdiciar demasiada memoria. La
misma tcnica puede aplicarse a la inversa, para evitar que el
factor de carga sea excesivamente bajo (desperdicio de
memoria).
Puede demostrarse que, aunque una operacin individual
podra llegar tener coste (n), una secuencia de n
operaciones de actualizacin tendr coste total (n).
Divide y vencers
Tablas de Hash
Colas de prioridad
Grafos y Recorridos
Una cola de prioridad (cat: cua de prioritat; ing: priority queue)

es una coleccin de elementos donde cada elemento tiene
asociado un valor susceptible de ordenacin denominado
prioridad.
Una cola de prioridad se caracteriza por admitir inserciones de
nuevos elementos y la consulta y eliminacin del elemento de
mnima (o mxima) prioridad.
template <typename Elem, typename Prio>

class ColaPrioridad {
public:
...
// Aade el elemento x con prioridad p a la cola de
// prioridad.
void inserta(cons Elem& x, const Prio& p) throw(error)
// Devuelve un elemento de mnima prioridad en la cola de
// prioridad. Se lanza un error si la cola est vaca.
Elem min() const throw(error);
// Devuelve la mnima prioridad presente en la cola de
Prio prio_min() const throw(error);
// Elimina un elemento de mnima prioridad de la cola de
void elim_min() throw(error);
// Devuelve cierto si y slo si la cola est vaca.
bool vacia() const throw();
};
// Tenemos dos arrays Peso y Simb con los pesos atmicos

// y smbolos de n elementos qumicos,
// p.e., Simb[i] = "C" y Peso[i] = 12.2.
// Utilizamos una cola de prioridad para ordenar la
// informacin de menor a mayor smbolo en orden alfabtico
ColaPrioridad<double, string> P;
for (int i = 0; i < n; ++i)
P.inserta(Peso[i], Simb[i]);
int i = 0;
while(not P.vacia()) {
Peso[i] = P.min();
Simb[i] = P.prio_min();
++i;
P.elim_min();
}
Se puede usar una cola de prioridad para hallar el k-simo

elemento de un vector no ordenado. Se colocan los k primeros
elementos del vector en una max-cola de prioridad y a
continuacin se recorre el resto del vector, actualizando la cola
de prioridad cada vez que el elemento es menor que el mayor
de los elementos de la cola, eliminando al mximo e insertando
el elemento en curso.
Muchas de las tcnicas empleadas para la implementacin

de diccionarios puede usarse para implementar colas de
prioridad (no las tablas de hash ni los tries)
P.e., con rboles binarios de bsqueda equilibrados se
puede conseguir coste O(log n) para inserciones y
eliminaciones
Definicin
Un montculo (ing: heap) es un rbol binario tal que
1
todos las hojas (subrboles son vacos) se sitan en los

dos ltimos niveles del rbol.
en el antepenltimo nivel existe a lo sumo un nodo interno

con un slo hijo, que ser su hijo izquierdo, y todos los
nodos a su derecha en el mismo nivel son nodos internos
sin hijos.
el elemento (su prioridad) almacenado en un nodo

cualquiera es mayor (menor) o igual que los elementos
almacenados en sus hijos izquierdo y derecho.
Se dice que un montculo es un rbol binario quasi-completo

debido a las propiedades 1-2. La propiedad 3 se denomina
orden de montculo, y se habla de max-heaps o min-heaps
segn que los elementos sean que sus hijos.
Proposicin
1
El elemento mximo de un max-heap se encuentra en la

raz.
Un heap de n elementos tiene altura

h = dlog2 (n + 1)e.
La consulta del mximo es sencilla y eficiente pues basta

examinar la raz.
Cmo eliminar el mximo?

1
Ubicar al ltimo elemento del montculo (el del ltimo nivel

ms a la derecha) en la raz, sustituyendo al mximo
Reestablecer el invariante (orden de heap) hundiendo la

raz.
El mtodo hundir intercambia un nodo dado con el mayor de

sus dos hijos si el nodo es menor que alguno de ellos, y repete
este paso hasta que el invariante de heap se ha reestablecido
Cmo aadir un nuevo elemento?

1
Colocar el nuevo elemento como ltimo elemento del

montculo, justo a la derecha del ltimo o como primero de
un nuevo nivel
Reestablecer el orden de montculo flotando el elemento

recin aadido
En el mtodo flotar el nodo dado se compara con su nodo

padre y se realiza el intercambio si ste es mayor que el padre,
iterando este paso mientras sea necesario
Puesto que la altura del heap es (log n) el coste de

inserciones y eliminaciones ser O(log n).
Se puede implementar un heap mediante memoria dinmica,
con apuntadores al hijo izquierdo y derecho y tambin al padre
en cada nodo
Pero es mucho ms fcil y eficiente implementar los heaps
mediante un vector. No se desperdicia demasiado espacio ya
que el heap es quasi-completo; en caso necesario puede
usarse el redimensionado
Reglas para representar un heap en vector:

1
A[1] contiene la raz.
Si 2i n entonces A[2i] contiene al hijo izquierdo del

elemento en A[i] y si 2i + 1 n entonces A[2i + 1]
contiene al hijo derecho de A[i]
Si i 2 entonces A[i/2] contiene al padre de A[i]
Las reglas anteriores implican que los elementos del heap se

ubican en posiciones consecutivas del vector, colocando la raz
en la primera posicin y recorriendo el rbol por niveles, de
izquierda a derecha.
class ColaPrioridad {
public:
...
private:
// la componente 0 no se usa; el constructor de la clase
// inserta un elemento ficticio
vector<pair<Elem, Prio> > h;
int nelems;
void flotar(int j) throw();
void hundir(int j) throw();
};

bool ColaPrioridad<Elem,Prio>::vacia() const throw() {
return nelems == 0;
}
Elem ColaPrioridad<Elem,Prio>::min() const throw(error) {
if (nelems == 0) throw error(ColaVacia);
return h[1].first;
}
Prio ColaPrioridad<Elem,Prio>::prio_min() const throw(error) {
return h[1].second;
}

void ColaPrioridad<Elem,Prio>::inserta(cons Elem& x,
cons Prio& p) throw(error) {
++nelems;
h.push_back(make_pair(x, p));
flotar(nelems);
}
void ColaPrioridad<Elem,Prio>::elim_min() const throw(error) {
swap(h[1], h[nelems]);
--nelems;
h.pop_back();
hundir(1);
}
//
//
//
//
Versin recursiva.
Hunde el elemento en la posicin j del heap
hasta reestablecer el orden del heap; por
hiptesis los subrboles del nodo j son heaps.
// Coste: O(log(n/j))
void ColaPrioridad<Elem,Prio>::hundir(int j) throw() {
// si j no tiene hijo izquierdo, hemos terminado
if (2 * j > nelems) return;
int minhijo = 2 * j;
if (minhijo < nelems and
h[minhijo].second > h[minhijo + 1].second)
++minhijo;
//
//
//
if
}
}
minhijo apunta al hijo de minima prioridad de j

si la prioridad de j es mayor que la de su menor hijo
intercambiar y seguir hundiendo
(h[j].second > h[minhijo].second) {
swap(h[j], h[minhijo]);
hundir(minhijo);
//
//
//
//
Versin iterativa.
Hunde el elemento en la posicin j del heap
hasta reestablecer el orden del heap; por
hiptesis los subrboles del nodo j son heaps.
// Coste: O(log(n/j))
void ColaPrioridad<Elem,Prio>::hundir(int j) throw() {
bool fin = false;
while (2 * j <= nelems and not fin) {
int minhijo = 2 * j;
if (minhijo < nelems and
h[minhijo].second > h[minhijo + 1].second)
++minhijo;
if (h[j].second > h[minhijo].second) {
swap(h[j], h[minhijo]);
j = minhijo;
} else {
fin = true;
}
}
}
// Flota al nodo j hasta reestablecer el orden del heap;

// todos los nodos excepto el j satisfacen la propiedad
// de heap
// Coste: O(log j)
void ColaPrioridad<Elem,Prio>::flotar(int j) throw() {
// si j es la raz, hemos terminado
if (j == 1) return;
int padre = j / 2;
// si el padre tiene mayor prioridad
// que j, intercambiar y seguir flotando
if (h[j].second < h[padre].second) {
swap(h[j], h[padre]);
flotar(padre);
}
}
Heapsort
Heapsort (Williams, 1964) ordena un vector de n elementos

construyendo un heap con los n elementos y extrayndolos,
uno a uno del heap a continuacin. El propio vector que
almacena a los n elementos se emplea para construir el heap,
de modo que heapsort acta in-situ y slo requiere un espacio
auxiliar de memoria constante. El coste de este algoritmo es
(n log n) (incluso en caso mejor) si todos los elementos son
diferentes.
En la prctica su coste es superior al de quicksort, ya que el
factor constante multiplicativo del trmino n log n es mayor.
// Ordena el vector v[1..n]

// (v[0] no se usa)
// de Elems de menor a mayor
template <typename Elem>
void heapsort(Elem v[], int n) {
crea_max_heap(v, n);
for (int i = n; i > 0; --i) {
// saca el mayor elemento del heap
swap(v[1], v[i]);
// hunde el elemento de indice 1
// para reestablecer un max-heap en
// el subvector v[1..i-1]
hundir(v, i-1, 1);
}
}
// Da estructura de max-heap al
// vector v[1..n] de Elems; aqu
// cada elemento se identifica con su
// prioridad
template <typename Elem>
void crea_max_heap(Elem v[], int n) {
for (int i = n/2; i > 0; --i)
hundir(v, n, i);
}
Sea H(n) el coste en caso peor de heapsort y B(n) el coste

de crear el heap inicial. El coste en caso peor de
hundir(v, i 1, 1) es O(log i) y por lo tanto
H(n) = B(n) +
i=n
X
O(log i)
i=1
= B(n) + O
log2 i
1in
= B(n) + O(log(n!)) = B(n) + O(n log n)

Un anlisis simple de B(n) indica que B(n) = O(n log n) ya
que hay (n) llamadas a hundir, cada una de las cuales tiene
coste O(log n)
Por tanto H(n) = O(n log n), de hecho H(n) = (n log n) en
caso peor
Podemos refinar el anlisis de B(n):

X
B(n) =
O(log(n/i))
1ibn/2c
!
nn/2
= O log
(n/2)!

= O log(2e)n/2 = O(n)
Puesto que B(n) = (n), podemos afirmar que B(n) = (n).
Demostracin alternativa: Sea h = dlog2 (n + 1)e la altura del

heap. En el nivel h 1 k hay como mucho
2h1k <
n+1
2k
nodos y cada uno de ellos habr de hundirse en caso peor

hasta el nivel h 1; eso tiene coste O(k)
Por lo tanto,
n+1
2k
0kh1
X k
= O n
2k
0kh1
X k
= O(n),
= O n
2k
B(n) =
O(k)
k0
ya que
X k
= 2.
2k
k0
En general, si |r| < 1,

X
k0
k rk =
r
.
(1 r)2
Aunque H(n) = (n log n), el anlisis detallado de B(n) es

importante: utilizando un min-heap podemos hallar los k
menores elementos en orden creciente de un vector (y en
particular el k-simo) con coste:
S(n, k) = B(n) + k O(log n)
= O(n + k log n).
y si k = O(n/ log n) entonces S(n, k) = O(n).
Divide y vencers
Tablas de Hash
Colas de prioridad
Grafos y Recorridos
Definicin
Un grafo (no dirigido) es un par G = hV, Ei donde V es un
conjunto finito de vrtices (tambin llamados nodos) y E es un
conjunto de aristas; cada arista e E es un par no ordenado
{u, v} donde u y v (u 6= v) son elementos de V .
Definicin
Un grafo dirigido o digrafo es un par G = hV, Ei donde V es un
conjunto finito de vrtices o nodos y E es un conjunto de arcos;
cada arco e E es un par (u, v) donde u y v (u 6= v) son
elementos de V .
Si en vez de un conjunto de arcos o aristas tenemos

multiconjuntos de arcos o aristas, y se permiten bucles (esto
es, arcos de la forma (u, u) o aristas {u, u}) entonces tenemos
multigrafos (dirigidos y no dirigidos, respectivamente).
Dado un arco e = (u, v) se denomina origen a u y destino a v.
Se dice que u es un predecesor de v y que v es un sucesor de
u. Para una arista e = {u, v} se dice que u y v son sus
extremos, que la arista es incidente a u y v, que u y v son
adyacentes.
Definicin
Un camino P = v0 , v1 , v2 , . . . , vn de longitud n en un grafo
G = hV, Ei es una secuencia de vrtices de G tal que para
toda i, 0 i < n
{vi , vi+1 } E
El vrtice v0 es el origen del camino P y vn es su destino.
Un camino en un digrafo se define de manera anloga: para
cada i, (vi , vi+1 ) es un arco del digrafo.
Se dice que un camino es simple si no se repite ningn vrtice.
Un camino en el que v0 = vn es un ciclo.
Definicin
Un grafo G = hV, Ei es conexo si y slo si, para todo par de
vrtices u y v, existe un camino que va de u a v en G.
Para digrafos la definicin es idntica, slo que entonces se
dice que el digrafo es fuertemente conexo.
Definicin
Dado un grafo G = hV, Ei, el grafo H = hV 0 , E 0 i se dice que es
un subgrafo de G si y slo si V 0 V , E 0 E, y para toda arista
e0 = (u0 , v 0 ) E 0 se cumple que u0 y v 0 pertenecen a V 0 .
Si E 0 contiene todas las aristas de E que son incidentes a dos
vrtices de V 0 , se dice que H es el subgrafo inducido por V 0 .
La definicin de subgrafo de un grafo dirigido es
completamente anloga.
Definicin
Una componente conexa C de un grafo G es un subgrafo
inducido maximal conexo de G. Maximal quiere decir que si se
aade cualquier vrtice v a V (C) entonces el subgrafo
inducido correspondiente no es conexoen particular, no
existe camino entre v y los restantes vrtices de C.
En el caso de digrafos, se habla de componentes fuertemente
conexas: una componente fuertemente conexa del digrafo G es
un subgrafo dirigido inducido maximal fuertemente conexo.
Definicin
Un grafo conexo y sin ciclos se denomina rbol (libre). Si G es
un grafo conexo, un subgrafo T = hV, E 0 i (es decir que
contiene los mismos vrtices que G) es un rbol de expansin
si T es un rbol.
Los rboles libres no tienen raz, y no existe orden entre los
vrtices adyacentes a un vrtice dado del rbol.
Lema
Si G = hV, Ei es un rbol entonces |E| = |V | 1.
A menudo trabajaremos con grafos o digrafos con etiquetas en

las aristas o arcos: el etiquetado de un grafo o digrafo es una
funcin : E L entre el conjunto de aristas o arcos de G y el
conjunto (eventualmente infinito) de etiquetas L.
Cuando las etiquetas son nmeros (enteros, racionales,
reales), se dice que el grafo o digrafo es ponderado y a la
etiqueta (e) de una arista o arco e se le suele denominar peso.
Implementacin
Los grafos se implementan habitualmente de una de las dos

siguientes formas:
1
Mediante matrices de adyacencia: la componente A[i, j]

de la matriz nos dice si el arco entre los vrtices i y j
existe o no; eventualmente, A[i, j] puede contener tambin
el peso del arco entre los vrtices i y j
Mediante listas de adyacencia: tenemos una tabla T de

listas enlazadas; la lista T [i] es la lista de sucesores del
vrtice i
La implementacin mediante matrices de adyacencia es muy

costosa en espacio: si |V | = n, se requiere espacio (n2 ) para
representar el grafo, independientemente del nmero de
aristas/arcos que haya en el grafo. Slo es interesante si
necesitamos poder decidir la existencia (o no) de una arista o
arco con mxima eficiencia.
Por regla general, la implementacin que se usar es la de
listas de adyacencia. El espacio que se requiere es (n + m),
donde m = |E| y n = |V |; el espacio utilizado es por lo tanto
lineal respecto al tamao del grafo.
typedef int vertex;

typedef pair<vertex, vertex> edge;
typedef list<edge>::iterator edge_iter;
class Graph {
// grafos no dirigidos con V = {0, ..., n-1}
public:
// crea un grafo vaco (sin vrtices y sin aristas)
Graph();
// crea un grafo con n vrtices y sin aristas
Graph(int n);
// aade un vrtice al grafo; el nuevo vrtice tendr
// identificador n, donde n era el nmero de vrtices
// del grafo antes de aadir el vrtice
void add_vertex();
// aade la arista (u,v) o e = (u,v) al grafo
void add_edge(vertex u, vertex v);
void add_edge(edge e);
// consultoras del numero de vertices y de aristas
int nr_vertices() const;
int nr_edges() const;
// devuelve lista de adyacentes a un vertice
list<edge> adjacent(vertice u) const;
...
private:
int n, m;
vector<list<edge> > T;
...
}
Recorridos
Definicin
Dado un grafo conexo G = hV, Ei, un recorrido del grafo es una
secuencia que contiene todos y cada uno de los vrtices en
V (G) exactamente una vez y tal que para cualquier vrtice v
en la secuencia se cumple que, o bien v es el primer vrtice de
la secuencia, o bien existe una arista e E(G) que une al
vrtice v con otro vrtice que le precede en la secuencia.
El recorrido de un grafo es una secuencia de los recorridos de
las componentes conexas de G. No hay ningn vrtice que
aparezca en el recorrido sin que se haya completado el
recorrido de las componentes conexas correspondientes a los
vrtices que le preceden en el recorrido.
En el caso de los digrafos, un recorrido que comienza en un

cierto vrtice v visitar todos y cada uno de los vrtices
accesibles desde v exactamente una vez; la visita de un vrtice
w 6= v implica que existe algn otro vrtice visitado
previamente del cual w es sucesor.
Los recorridos nos permiten visitar todos los vrtices de un
grafo, con arreglo a la topologa del grafo, pues se utilizan las
aristas o arcos del grafo para ir haciendo las sucesivas visitas.
Mediante un recorrido (o una combinacin de recorridos)

podemos resolver eficientemente numerosos problemas sobre
grafos. Por ejemplo
Determinar si un grafo es conexo o no
Hallar las componentes conexas de un grafo no dirigido
Hallar las componentes fuertemente conexas de un grafo
dirigido
Determinar si un grafo contiene ciclos o no
Decidir si un grafo es 2-coloreable, equivalentemente, si es
bipartido
Decidir si un grafo es biconexo o no (la eliminacin de un
vrtice no desconecta al grafo)
Hallar el camino ms corto (con menor nmero de
aristas/arcos) entre dos vrtices dados
etc.
Recorrido en profundidad (DFS)
En el recorrido en profundidad (ing: Depth-First Search, DFS)

de un grafo G, se visita un vrtice v y desde ste,
recursivamente, se realiza el recorrido de cada uno de los
vrtices adyacentes/sucesores de v no visitados.
Cuando se visita por vez primera un vrtice v se dice que se ha
abierto el vrtice; el vrtice se cierra cuaando se completa,
recursivamente, el recorrido en profundidad de los vrtices
adyacentes/sucesores.
La numeracin directa o numeracin DFS de un vrtice es el

nmero de orden en el que se abre el vrtice; as, el vrtice en
el que se inicia el recorrido tiene numeracin directa 1.
La numeracin inversa de un vrtice es el nmero de orden en
el que se cierra el vrtice. El primer vrtice del recorrido para el
cual todos sus vecions/sucesores ya han sido visitados tiene
numeracin inversa 1, y as sucesivamente.
. visitado, ndf s, ninv, num_df s, num_inv son variables globales

procedure DFS(G)
for v V (G) do
visitado[v] := false
ndf s[v] := 0; ninv[v] := 0
end for
num_df s := 0; num_inv := 0
for v V (G) do
if visitado[v] then
DFS-R EC(G, v, v)
end if
end for
end procedure
procedure DFS-R EC(G, v, padre)

PRE-VISIT(v)
visitado[v] := true
num_df s := num_df s + 1; ndf s[v] := num_df s
for w G.A DJACENT(v) do
if visitado[w] then
PRE-VISIT-EDGE(v, w)
DFS-R EC(G, w, v)
POST-VISIT-EDGE(v, w)
else
. si w 6= padre entonces hemos encontrado un ciclo
end if
end for
POST-VISIT(v)
num_inv := num_inv + 1; ninv[v] := num_inv
end procedure
// Macros para escribir recorridos en un grafo

#define forall(v,G) for(vertex (v) = 0; (v) < (G).nr_vertices(); ++(v))
#define forall_adj(e, u, G) \
for(edge_iter (e) = (G).adjacent((u)).begin(); \
(e) != (G).adjacent((u))].end() ; ++(e))
#define target(eit) ((eit) -> second)
#define source(eit) ((eit) -> first)
void DFS(const Graph& G) {

vector<bool> visitado(G.nr_vertices(), false);
vector<int> ndfs(G.nr_vertices(), 0);
vector<int> ninv(G.nr_vertices(), 0);
int num_dfs = 0;
int num_inv = 0;
forall(v, G)
if (not visitado[v])
DFS(G, v, v, visitado, num_dfs, num_inv, ndfs, ninv);
}
void DFS(const Graph& G, vertex v, vertex padre,

vector<bool>& visitado,
int& num_dfs, int& num_inv,
vector<int>& ndfs,
vector<int>& ninv) {
PRE-VISIT(v);
visitado[v] = true;
++num_dfs; ndfs[v] = num_dfs;
forall_adj(e, v, G) {
vertex w = target(e);
if (not visitado[w]) {
PRE-VISIT-EDGE(v,w);
DFS(G, w, v, visitado, num_dfs, num_inv, ndfs, ninv);
POST-VISIT-EDGE(v,w);
} else {
// si w != padre entonces hemos encontrado un ciclo
}
}
POST-VISIT(v);
++num_inv; ninv[v] = num_inv;
}
El recorrido en profundidad de una componente conexa induce

un rbol de expansin, al que se denomina rbol del recorrido
TDFS .
Las aristas de la componente conexa se clasifican entonces en
aristas de rbol (tree edges) y aristas de retroceso (backward
edges). stas ltimas unen el vrtice que se acaba de abrir con
un vrtice visitado (abierto o cerrado) y por tanto cierran ciclos.
El recorrido de todo el grafo da lugar a un bosque de
expansin.
Para cada vrtice v, CC[v] ser el nmero de la componente

conexa en la que est v. T reeEdges[i] es el conjunto de aristas
de rbol en la componente i, y BackEdges[i] el conjunto de
aristas de retroceso. El nmero de componentes conexas
viene dado por ncc.
procedure DFS(G)
for v V (G) do
CC[v] := 0
end for
ncc := 0
for v V (G) do
if visitado[v] then
ncc := ncc + 1
T reeEdges[ncc] :=
BackEdges[ncc] :=
DFS-R EC(G, v, v)
end if
end for
end procedure
procedure DFS-R EC(G, v, padre)

visitado[v] := true
CC[v] := ncc
if visitado[w] then
T reeEdges[ncc] := T reeEdges[ncc] {(v, w)}
DFS-R EC(G, w, v)
else if w 6= padre then
BackEdges[ncc] := BackEdges[ncc] {(v, w)}
end if
end for
end procedure
a
e
i
g
c
d
h
f
j
k
k
tree edge
backward edge
h
d
i
e
l
j
Aplicaciones del DFS
Detectar ciclos o calcular las componentes conexas son

ejemplos triviales de aplicacin del recorrido en profundidad.
Otro algoritmo simple que se puede disear aplicando el DFS
es determinar si un grafo es bipartido. Recordemos que un
grafo G es bipartido si existe una particin hA, Bi del conjunto
de vrtices V (es decir, A B = V ; A B = ) tal que toda
arista de G tiene un extremo en A y el otro en B:
Equivalentemente, G es bipartido si y slo si es 2-coloreable, y
si y slo si no contiene ningn ciclo de longitud impar (porqu?)
procedure E S B IPARTIDO(G)
for v V (G) do
color[v] := 1
end for
color := 0
es_bip := true
for v V (G) while es_bip do
if color[v] = 1 then
es_bip := E S B IPARTIDO -R EC(G, v, color)
end if
end for
return es_bip
end procedure
procedure E S B IPARTIDO -R EC(G, v, c)

es_bip := true
color[v] := c
for w G.A DJACENT(v) while es_bip do
if color[w] = 1 then
es_bip := E S B IPARTIDO -R EC(G, w, v, 1 c)
else
es_bip := (c 6= color[w])
end if
end for
return es_bip
end procedure
Aplicaciones del DFS: Grafos Biconexos

Un grafo conexo G se dice que es biconexo si al eliminar uno
cualquiera de sus vrtices sigue siendo conexo.
Supongamos que efectuamos un DFS empezando en el vrtice
r y que para cada vrtice u determinamos el nmero DFS ms
bajo que es alcanzable siguiendo un camino desde u hasta
uno de sus descendientes en el TDFS y a continuacin
subimos con una arista de retroceso. Denominaremos
mas_alto[u] a dicho nmero.
r
mas_alto[u] = nd[x]
Un vrtice u es un punto de articulacin de G si su eliminacin

desconecta el grafo. Si G no tiene puntos de articulacin
entonces G es biconexo. Para ver si un vrtice es punto de
articulacin o no debermos considerar varios casos:
1
u es una hoja del TDFS (no tiene descendientes): entonces

no es un punto de articulacin ya que nunca se
desconectar el grafo
u = r es la raz del TDFS : es punto de articulacin si y slo

si tiene ms de un descendiente en el TDFS , su eliminacin
desconectara los subrboles, pero si slo hay uno su
eliminacin no desconecta a los dems vrtices.
u no es hoja y no es la raz: entonces es punto de

articulacin si y slo si alguno de los vrtices adyacentes
descendientes w de u cumple mas_alto[w] ndf s[u], es
decir, si algn descendiente no puede escapar del
subrbol enraizado en u sin pasar por u.
Por otro lado para cada vrtice u, mas_alto[u] es el mnimo

entre: 1) ndf s[u], 2) mas_alto[v] para todo v descendiente
directo de u en el TDFS y 3) ndf s[v] para todo v adyacente a u
mediante una arista de retroceso.
procedure B ICONEXO(G)
Require: G es conexo
for v V (G) do
ndf s[v] := 0
punto_art[v] := false
num_desc[v] := 0
end for
num_df s := 0
es_biconexo := true
. Basta lanzar un DFS porque G es conexo
v := un vrtice cualquiera de G
B ICONEXO -R EC(G, v, v, es_biconexo, ndf s, . . .)
return es_biconexo
end procedure
procedure B ICONEXO -R EC(G, v, padre, . . . )

num_df s := num_df s + 1; ndf s[v] := num_df s
visitado[v] := true
mas_alto[v] := ndf s[v]
if visitado[w] then
num_desc[v] := num_desc[v] + 1
B ICONEXO -R EC(G, w, v, . . .)
mas_alto[v] := min(mas_alto[v], mas_alto[w])
punto_art[v] := punto_art[v] (mas_alto[w] ndf s[v])
else if padre 6= w then
mas_alto[v] := min(mas_alto[v], ndf s[w])
end if
end for
if v = padre then . v es la raz del TDFS
punto_art[v] := num_desc[v] > 1
end if
es_biconexo := es_biconexo punto_art[v]
end procedure
Anlisis del DFS
Supongamos que el trabajo que se realiza en cada visita de un

vrtice (PRE- y POST-VISIT) y cada visita de una arista, sea
del rbol o de retroceso, es (1). Entonces el coste del DFS es
X

(1) + (grado(v)) =
vV
X

1 + grado(v)
!
=
vV
X
vV
1+
X
vV
grado(v)
= (n + m)
DFS en Digrafos
El recorrido en profundidad de un digrafo tiene propiedades

algo distintas de las del DFS de un grafo no dirigido. Al lanzar
un DFS desde un vrtice v de un digrafo G se visitarn los
vrtices (no visitados) de la componente fuertemente conexa
de v pero adems todos los otros vrtices accesibles desde v.
El DFS de un digrafo induce sucesivos rboles de recorrido,
enraizados en los vrtices desde los cuales se lanzan los
recorridos recursivos. Los conceptos de numeracin DFS y de
numeracin inversa son igual que en el caso de grafos no
dirigidos.
El DFS de un digrafo tambin induce una clasificacin de los

arcos, pero es algo diferente:
1
Arcos de rbol: van del vrtice v en curso a un vrtice no

visitado w
Arcos de retroceso: van del vrtice v en curso a un vrtice

antecesor w en el rbol TDFS ; se cumple que
ndf s[w] < ndf s[v] y que ndf s[w] est abierto
Arcos de avance (forward edges): van del vrtice v en

curso a un vrtice descendiente pero previamente visitado
w en el TDFS ; se cumple que ndf s[v] < ndf s[w]
Arcos de cruce (cross edges): van del vrtice v en curso a

un vrtice previamente visitado w en el mismo TDFS o en
un rbol diferente; se cumple que ndf s[w] < ndf s[v], pero
el vrtice w ya est cerrado (ninv[w] 6= 0)
e
i
g
c
h
f
tree edge
m
j
k
k
backward edge
forward edge
cross edge
Resto de la seccin sobre Grafos y Recorridos:

Conceptos Básicos de Algorítmica

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Conceptos Básicos de Algorítmica

Cargado por

Copyright:

Formatos disponibles

Conceptos Bsicos de Algortmica

Queda prohibida la reproduccin parcial o la modificacin, por

rboles binarios de bsqueda

rboles balanceados (AVLs)

Eficiencia de un algoritmo = consumo de recursos de

En general, dado un algoritmo A cuyo conjunto de entradas es

Sea An el conjunto de entradas de tamao n y Tn : An N la

Para todo n 0 y para cualquier An

Estudiaremos generalmente slo el coste en caso peor:

Proporciona garantas sobre la eficiencia del algoritmo, el

Es ms fcil de calcular que el coste promedio

Una caracterstica esencial del coste (en caso peor, en caso

Funciones lineales: f (n) = a n + b f (2n) 2 f (n)

Se dice que las funciones lineales y las cuadrticas tienen

Los factores constantes y los trminos de orden inferior son

p.e. 30n2 + n tiene la misma tasa de creciemiento que

En palabras, una funcin g est en O(f ) si existe una constante

Aunque O(f ) es un conjunto de funciones por tradicin se

Es reflexiva: para toda funcin f : R+ R+ , f = O(f )

Es transitiva: si f = O(g) y g = O(h) entonces f = O(h)

Para toda constante c > 0, O(f ) = O(c f )

Los factores constantes no son relevantes en la notacin

Otras notaciones asintticas son (omega) y (zita). La

La notacin es reflexiva y transitiva; si lmn g(n)/f (n) > 0

Se dice que O(f ) es la clase de las funciones que crecen no

Propiedades adicionales de las notaciones asintticas (las

Para cualesquiera constantes < , si f es una funcin

Para cualesquiera constantes a y b > 0, si f es creciente,

Para cualquier constante c > 1, si f es creciente,

Los operadores convencionales (sumas, restas, divisiones,

Regla de las sumas:

Anlisis de algoritmos iterativos

El coste de una operacin elemental es (1).

Si el coste de S1 es f , el de S2 es g y el coste de evaluar B

Si el coste de S durante la i-sima iteracin es fi , el coste

Si f = max{fi + hi } entonces T = O(f g).

Anlisis de algoritmos recursivos

rboles binarios de bsqueda

rboles balanceados (AVLs)

El principio bsico de divide y vencers (en ingls, divide and

Si el ejemplar (instancia) del problema a resolver es

En caso contrario, se divide o fragmenta el ejemplar dado

Las soluciones obtenidas y1 , . . . , yk se combinan para

El esquema de divide y vencers expresado en

Ocasionalmente, si k = 1, se habla del esquema de

El esquema de divide y vencers se caracteriza

Coste de los algoritmos divide y vencers

Demostraci 21 n: Supondremos que n = n0 bj . Aplicando la

Puesto que f (n0 ) es una constante y tenemos que el segundo

Si = k, tendremos que a/bk = 1 y la suma vale j; ya que

Por tanto, es el segundo trmino el que en este caso domina y

. Llamada inicial: B IN S EARCH(A, x, 0, n + 1)

La llamada inicial es B IN S EARCH(()A, x, 0, A.SIZE() + 1),

y B(0) = b0 , ya que en cada llamada recursiva slo se hace

Algoritmo de Karatsuba y Ofmann

El algoritmo tradicional de multiplicacin tiene coste (n2 ) para

Tambi 12 es de coste cuadr 21 tico el algoritmo de

Supongamos que x e y son dos nmeros positivos de n = 2k

Efectuada la descomposicin x = hA, Bi y y = hC, Di, se

cuya solucin es M (n) = (n2 ). En este caso = 1, a = 4 y

El algoritmo de Karatsuba y Ofmann (1962) realiza la

El algoritmo requiere realizar 6 adiciones (una de ellas es de

M (n) = (n) + 3 M (n/2)

Ordenacin por fusin