Tabla de Contenidos

Tabla de Contenidos
1. Estructuras de Datos Simples 3
1.1. Stacks y Colas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2. Heaps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3. Listas Doblemente Ligadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.4. Representación de Árboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.5. Implementación de Punteros y Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.6. Definición Algebráica de una Estructura de Datos . . . . . . . . . . . . . . . . . . . 20
2. Algoritmos de Ordenación 21
2.1. Algoritmos Simples de Ordenación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2. Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.3. Quicksort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.4. Ordenación en Tiempo Esperado Lineal . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.5. Estadísticas de Orden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3. Estructuras de Datos para Diccionarios 35
3.1. Tablas de Hash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2. Árboles Binarios de Búsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3. Árboles AVL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4. Árboles Rojo–Negro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.5. SkipLists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.6. Aumento de una Estructura de Datos . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4. Estructuras de Datos Externas 37
4.1. Indexación Secuencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2. Árboles–B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1

2 TABLA DE CONTENIDOS
5. Otras Estructuras de Datos 39
5.1. Estructuras para Conjuntos Disjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.2. Heaps Binomiales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3. Heaps de Fibbonacci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6. Técnicas Fundamentales de Diseño de Algoritmos 41
6.1. Analisis Amortizado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.2. Algoritmos Codiciosos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.3. Divir para Conquistar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.4. Programación Dinámica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
7. Algoritmos en Grafos 43
7.1. Recorridos en Profundidad y Amplitud . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.2. Orden Topológico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.3. Componentes Fuertemente Conexas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.4. Árboles de Cobertura de Costo Mínimo . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.5. Caminos más Cortos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.6. Flujo Máximo en Redes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
8. Algoritmos sobre Strings 45
8.1. Pattern Matching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
8.2. Pattern Matching de Expresiones Regulares . . . . . . . . . . . . . . . . . . . . . . . 45
8.3. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
9. Estructuras y Algoritmos para Computación Gráfica 47
9.1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
10.Introducción a la Complejidad Computacional 49
10.1. Las clases de problemas P y NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
10.2. Problemas NP-duros y NP-completos . . . . . . . . . . . . . . . . . . . . . . . . . . 49
10.3. La clase co-NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
10.4. Más allá de P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
10.5. Dentro de P . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

Capítulo
1
Estructuras de Datos Simples
1.1. Stacks y Colas
Stacks
Un stack es una estructura que sólo implementa una operación de consulta o extracción de datos.
El elemento retornado está predeterminado por la forma en que los elementos fueron agregados al
stack, siguiendo una política LIFO (Last In First Out) que significa que el elemento retornado por
una operación de consulta es siempre el último elemento insertado. La operación de extracción sobre
un stack se llama Pop y diremos que retorna siempre el elemento que se encuentra al tope del stack.
La operación de inserción en un stack se llama Push y recibe un único argumento. Después de
una operación Push(x) el elemento al tope del stack es x y debiera ser el elemento retornado por
una subsiguiente operación Pop.
Podemos implementar un stack usando un arreglo S para almacenar los elementos y un puntero
top que nos indique la posición del elemento al tope del stack. El valor de top es inicialmente −1 y
supondremos que el arreglo para implementar el stack tiene un tamaño fijo, digamos N.
Stack:
S[0..N − 1]
top := −1
Una observación importante es que se debe tener cuidado de hacer Pop a un stack vacío. Implementamos
entonces un método llamado IsEmpty que retorna true si el stack se encuentra vacío
y false en otro caso. Es fácil darse cuenta que para decidir acerca de si el stack se encuentra o no
vacío, sólo debemos mirar el puntero top.
3

4 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
Figura 1.1: Ejemplo de las operaciones Pop y Push aplicadas a un stack en particular.
Stack.IsEmpty()
if top = −1
then return true
else return false
Con las observaciones anteriores, las implementaciones de Push y Pop son:
Stack.Push(x)
top := top +1
S[top] := x
Stack.Pop()
if IsEmpty()
then error “underflow”
else top := top −1
return S[top +1]
Cada una de las operaciones IsEmpty, Push y Pop toman tiempo O(1). La figura 1.1 muestra
los efectos de las operaciones Push y Pop sobre un stack particular.
Colas
Al igual que un stack, una cola implementa sólo una operación de consulta o extracción de datos.
También el elemento retornado por una operación de extracción en una cola está predeterminado
por la forma en que los elementos fueron insertados, esta vez obedeciendo una política FIFO (First
In First Out), es decir, el primer elemento insertado en la cola será el primer elemento retornado
por una operación de extracción.
En una cola la operación de extracción se llama Dequeue y diremos que retorna siempre el
elemento a la cabeza de la cola. Este elemento representa al elemento que primero fue insertado
en la cola de entre los que aún se encuentran en ella. La operación de inserción sobre una cola se
llama Enqueue y recibe un único argumento. Diremos que luego de una operación Enqueue(x) el
elemento x queda al final de la cola (o a la cola de la cola).

1.1. STACKS Y COLAS 5
Figura 1.2: Ejemplo de las operaciones sobre una cola.
Podemos entonces implementar una cola usando un arreglo Q para almacenar los elementos y
dos punteros: head, que nos indique la posición del elemento a la cabeza de la cola, y tail, que nos
indique la posición siguiente al último elemento de la cola. Inicialmente los valores head y tail son
0 y supondremos que el arreglo tiene un tamaño fijo N.
Cola:
Q[0..N − 1]
head := 0
tail := 0
Los valores iniciales nos indican inmediatamente que una cola se encuentra vacía si se cumple
head = tail. Los dos punteros son necesarios para optimizar el uso del espacio en el arreglo. De
hecho, como se verá en la implementación, el uso del arreglo es en forma circular lo que implica que
se supone que la posición que sigue a Q[N − 1] es Q[0].
Las implementaciones de Enqueue y Dequeue resultan:
Cola.Enqueue(x)
Q[tail] := x
tail := tail +1 mod N
Cola.Dequeue()
x := Q[head]
head := head +1 mod N
return x
Es importante notar que en los procedimientos Enqueue y Dequeue pueden ocurrir tanto
errores de underflow como de overflow. El chequeo de estas condiciones se han omitido para mantener
la claridad de los procedimientos. Al igual que con el stack, todas las operaciones sobre una cola
toman tiempo O(1).
La figura 1.2 muestra un ejemplo de las operaciones de extracción e inserción sobre una cola
particular.

6 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
Ejercicios
1. Explique como se pueden implementar dos stacks usando sólo un arreglo S[0..N −1] de manera
tal que no se produzca un overflow a menos que entre los dos stacks alcancen un número total
de elementos insertados igual a N. Las operaciones Pop y Push deben seguir tomando tiempo
O(1).
1.2. Heaps
Un heap es una estructura que permite las operaciones básicas de conjuntos más la operación
Max de manera muy eficiente. Es por esto que la motivación inicial para esta estructura es el uso
en colas de prioridades. Además el heap tendrá aplicaciones directas en el capítulo 2 cuando veamos
el algoritmo Heap-Sort.
Un heap es un árbol binario semi–completo, o sea, que tiene todos sus niveles llenos excepto
posiblemente el último nivel, el que se encuentra lleno desde la izquierda hasta algún punto a la
derecha. La figura ?? en la sección ?? muestra un ejemplo de un árbol binario semi–completo.
Por la regularidad que tiene un árbol de las anteriores características, es posible implementar un
heap directamente sobre un arreglo sin la necesidad de utilizar punteros usando procedimientos para
plasmar la estructura de árbol. Dado un árbol binario semi–completo en un arreglo A[0..N − 1], la
raíz del árbol será A[0] y los siguientes procedimientos permiten obtener los índices del padre, hijo
izquierdo e hijo derecho del elemento con índice i:
P(i)
L(i)
R(i)
return ⌊ i−1
2 ⌋
return 2i + 1
return 2i + 2
Se debe tener especial cuidado en hacer la diferencia entre el largo total del arreglo y la cantidad
de posiciones del arreglo que se están usando como elementos efectivos del heap. Con estas
consideraciones podríamos definir un heap usando un arreglo A de largo N como sigue:
Heap
A[0..N − 1]
µ := N
π := 0
donde el atributo µ indica el largo total del arreglo usado para almacenar el heap, y π indica la
cantidad de elementos efectivamente almacenados en el heap, inicialmente 0. De esta forma, a pesar
de que pueden existir elementos válidos en A[0..µ−1], los elementos efectivos del heap se encuentran
en A[0..π − 1].

1.2. HEAPS 7
Figura 1.3: Ejemplo de Heap
Hasta ahora nuestra definición de heap no se diferencia en nada de un árbol binario. Lo que
caracteriza a un heap, es que el arreglo A cumple la propiedad de heap:
A[P(i)] ≥ A[i] (1.1)
En la figura 1.3 se muestra un ejemplo de un árbol binario semicompleto que cumple la propiedad
de heap. La anterior propiedad nos dice que en el árbol que representa al heap, el valor asignado a
un nodo es siempre mayor que sus dos hijos. Esta propiedad nos permite también, inmediatamente
dar un procedimiento para obtener el valor máximo dentro del heap:
Heap.Max()
if π > 0
then return A[0]
else return nil
El ejercicio 1 le pide demostrar que este procedimiento es correcto.
Para implementar cada una de las operaciones básicas sobre un heap debemos tener claro que,
tanto antes como después de la aplicación de cada una de ellas, la propiedad de heap debe cumplirse.
En lo que sigue estudiaremos cómo implementar las operación de inserción, y más adelante cómo
restaurar la propiedad de heap en un árbol semi-completo deficiente (como heap) lo que nos permitirá
implementar la operación de extracción.
Inserción
La operación de inserción en un heap se puede hacer de una forma bastante simple. El siguiente
trozo de código inserta el valor k en un heap.
Heap.Insert(k)
if π = µ
then error “heap overflow”
A[π] := k
i := π
while i > 0 ∧ A[i] > A[P(i)]
do intercambia(A[i],A[P(i)])
i := P(i)
π := π + 1

8 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
Figura 1.4: Ejemplo de ejecución de la función Insert sobre un heap.
La idea tras el procedimiento de inserción es que al intentar agregar un nuevo elemento al final
del arreglo, una posible violación a la propiedad de heap se puede dar sólo entre el nuevo valor y su
padre, en el caso de que el nuevo valor sea mayor que su padre. Este problema se arregla fácilmente
intercambiando los valores luego de lo cuál podría existir una posible nueva violación por lo que el
proceso debe repetirse. La complejidad de este procedimiento tiene directa relación con la altura del
árbol, esto porque en cada llamada recursiva estamos subiendo un nivel en el árbol. Dado que si
el heap tiene N elementos la altura máxima del árbol es Θ(log N) (es un árbol semi–completo), el
tiempo que toma Insert es Θ(log N) en el peor caso. La figura 1.4 muestra un ejemplo de inserción
de un nuevo valor en un heap.
Restaurando la propiedad de heap
Suponga que se quiere eliminar un elemento desde el heap, por ejemplo el que se encuentra en la
posición j. Podríamos hacer simplemente A[j] = nil para representar que el elemento en la posición
j ya no se encuentra en el heap. Existen muchos problemas que este tipo de eliminación generaría:
el árbol podría dejar de ser semi–completo incluso podría dejar de ser un árbol, podría existir un
problema en cómo actualizar el valor de π, etc. El alumno podría preguntarse si existe algún caso
en que hacer la eliminación de esta forma no produzca estos problemas.
El siguiente procedimiento recursivo Heapify se usa para restaurar la propiedad de heap a un
arreglo que ha dejado de cumplirla porque uno (y sólo uno) de sus elementos la está violando con
respecto a sus hijos (no tiene conflictos con el valor del padre), y tanto el subárbol izquierdo como
el derecho de este valor siguen cumpliendo la propiedad de heap. Esta operación nos servirá más
adelante no sólo para la extracción de elementos desde el heap, si no también para la construcción de
un heap a partir de valores arbitrarios. Toma como argumento un índice i tal que A[i] posiblemente
viola la propiedad de heap, o sea que puede ser menor que alguno de sus hijos en el heap.

1.2. HEAPS 9
Figura 1.5: Ejemplo de ejecución de Heapify sobre un heap deficiente en una de sus posiciones.
Heap.Heapify(i)
l := L(i)
r := R(i)
k := i
if l < π ∧ A[l] > A[k]
then k := l
if r < π ∧ A[r] > A[k]
then k := r
✄ k es el índice del mayor elemento entre A[i], A[l] y A[r]
if k ≠ i
then intercambia(A[i],A[k])
Heapify(k)
Hapify hace “descender” por el heap el valor en A[i], de modo que el subárbol con raíz en i se
vuelva un heap. Primero pone en la posición i al mayor de los valores entre A[i], A[l] y A[r], y si
el valor más grande no es A[i] hace una llamada recursiva sobre la nueva posición de A[i], ya que
la nueva posición podría nuevamente estar violando la propiedad de heap. La figura 1.5 muestra un
ejemplo de aplicar Heapify a un arreglo en que una de sus posiciones viola la propiedad de heap.
El tiempo que tarda Heapify(i) corresponde a la altura de A[i] en el árbol binario, esto porque
en cada llamada recursiva estamos descendiendo un nivel en el árbol. Dado que si el heap tiene N
elementos la altura máxima del árbol es Θ(log N) (es un árbol semi–completo), el tiempo que toma
Heapify es Θ(log N) en el peor caso. En el ejercicio 2 se pide demostrar que Heapify es correcto
y calcular usando relaciones de recurrencia su complejidad.
Construyendo un heap
Heapify nos permite “arreglar” un arreglo en el que sólo un valor le está impidiendo ser un
heap, pero qué pasa si tenemos un arreglo cualquiera y queremos convertirlo en un heap. En la
figura 1.6 se muestra un arreglo cualquiera y cómo se vería su estructura si se interpretara como un
árbol completo. En esta situación, sólo las hojas del árbol cumplen con seguridad la propiedad de
heap. Si por ejemplo aplicáramos Heapify a cada uno de los nodos de altura 2 obtendríamos varios
subárboles que cumplen la propiedad de heap. El resultado de esto se muestra en la figura 1.7. Esto
nos da una intuición para crear un procedimiento que a partir de un arreglo cualquiera pueda crear
un heap, la idea será aplicar Heapify por niveles partiendo de los de menor altura.

10 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
Figura 1.6: Un arreglo cualquiera visto como un árbol binario semicompleto.
Figura 1.7: Arreglo de la figura 1.6 despúes de aplicar Heapify a cada uno de los nodos de altura 2.
El siguiente procedimiento toma un arreglo A de tamaño N y entrega un heap con los mismos
valores del arreglo A.
Build-Heap(A)
Heap h
h.A := A
h.π := N
h.µ := N
for i := N − 1 downto 0
do h.Heapify(i)
return h
¿Qué complejidad tiene el procedimiento Build-Heap? Nuestra primera aproximación es apostar
por que toma tiempo O(N log N) en el peor caso para construir un heap a partir de un arreglo de
N elementos, esto porque sabemos que Heapify toma tiempo Θ(log N) en el peor caso y estamos
haciendo N llamadas al procedimiento. ¿Podemos dar una cota más ajustada? La respuesta es sí,
la observación clave es que el peor caso de Heapify ocurre cuando el nodo desde donde se llama
inicialmente al procedimiento está a la mayor altura posible, sin embargo en Build-Heap estamos
haciendo “muchas” llamadas sobre nodos de poca altura, de hecho, el procedimiento Heapify toma
tiempo Θ(1) si se llama sobre una hoja del árbol.
Teorema 1.2.1. Build-Heap toma tiempo O(N) en el peor caso para un arreglo de tamaño N.
Demostración. Antes de la demostración, haremos una observación. La cantidad de nodos de altura
h en un arbol binario completo con N nodos es exactamente ⌈N/2 h+1 ⌉. Esto se puede demostrar

1.2. HEAPS 11
por inducción en h y la clave está en notar que, si a altura h hay m nodos, a altura h + 1 hay m/2
nodos. El ejercicio 3 le pide hacer esta demostración.
Con esta observación podemos seguir con nuestra demostración inicial acerca de la complejidad
de Build-Heap. En Build-Heap se hace Heapify una vez para cada uno de los elementos del árbol
(arreglo) iniciando por los de menor altura. Si el nodo i tiene altura h i entonces, para i, Heapify
tarda Θ(h i ). Luego, para calcular el tiempo total que demora el procedimiento, podemos sumar los
tiempos por niveles en el árbol. Supongamos que el árbol tiene altura H, la suma resulta entonces:
h=0
H∑
h=0
⌈ N
2 h+1 ⌉
Θ(h)
como lo que buscamos es una notación O podemos reescribir la suma anterior como
( H
) ( )
∑ N
H∑
O
2 h+1 h h
= O N
2 h
necesitamos entonces solamente acotar la sumatoria interna. Es claro que la sumatoria cumple con
la desigualdad
H∑
h=0
∞
h
2 h < ∑
Usaremos algunos conocimientos de series, generalmente aprendidos en los cursos de cálculo, para
encontrar un valor explícito para esta última sumatoria. La sucesión geométrica (muy conocida por
los estudiantes de ingeniería) es la siguiente
y cuando n tiende a infinito obtenemos
1 + x + x 2 + · · · + x n =
1 + x + x 2 + · · · =
h=0
h
2 h .
n∑
h=0
∞∑
h=0
h=0
x h = 1 − xn+1
1 − x
x h = 1
1 − x .
que converge para todos los valores de x estrictamente menores que 1. Ahora podemos “derivar” la
anterior sumatoria 1 para obtener
1 + 2x + 3x 2 + 4x 3 + · · · =
∞∑
hx h−1 1
=
(1 − x) 2
que también converge para todos los valores de x estrictamente menores que 1. Lo único que nos
falta ahora es multiplicar lo anterior por x para obtener
x + 2x 2 + 3x 3 + 4x 4 + · · · =
h=1
∞∑
hx h x
=
(1 − x) 2
1 Esta derivación es permitida sólo por la convergencia uniforme de la serie geométrica, y es válida para los valores
de x estrictamente menores que 1.
h=0

12 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
que es exactamente la sumatoria que buscamos cuando x = 1/2, luego tenemos que
H∑
h=0
h
∞
2 h < ∑
h=0
Finalmente la complejidad de Build-Heap resulta:
O
(
N
H∑
h=0
1
h
2 h = 2
(1 − 1 = 2.
2
)2
)
h
2 h = O(N · 2) = O(N).
Este teorema nos dice que podemos crear un heap a partir de un arreglo cualquiera en tiempo
lineal en el largo del arreglo.
El anterior cálculo de complejidad se estableció como un teorema principalmente por la cantidad
de herramientas matemáticas necesarias, generalmente estos cálculos no serán tan engorrosos y por
esto no los estableceremos como teoremas. Se le recomienda al alumno aprender los resultados del
teorema, principalmente los cálculos de las sumatorias ya que estas pueden serle de utilidad en otros
cálculos de complejidad de algoritmos.
Extracción y Colas de Prioridades
Una cola de prioridades es una estructura de datos para mantener elementos de manera tal que
la extracción siempre entrega el elemento de mayor valor. Similarmente a un stack o una cola, en
una cola de prioridades el elemento que se extrae esta predeterminado por los elementos actualmente
en ella. Soporta las operaciones Insert, Max y Extract-Max.
Una típica aplicación de las colas de prioridades es la organización de las tareas que se deben
ejecutar en un servidor. Se ejecutará primero la tarea que tenga la más alta prioridad (claramente
una tarea del decano de la facultad tiene prioridad sobre una tarea pedida por un alumno). Cuando
una tarea es terminada (o interrumpida) se elige desde la cola la que tenga mayor prioridad de las
que se encuentran esperando usando la operación Extract-Max y esta será la próxima en ejecutar
en el servidor.
La implementación más simple de una cola de prioridades, pero muy ineficiente, es mantener
todos los elementos en un arreglo y cada vez que se pregunte por o se quiera extraer el de máximo
valor, este se busca linealmente en todo el arreglo.
Otra implementación simple, pero igual de ineficiente, es usar un arreglo ordenado en forma
creciente y un puntero (índice) al último elemento del arreglo. Cada vez que se ingresa un nuevo
elemento, este se ubica directamente en la posición que le corresponde según el orden y cuando se
pregunta por o se quiere extraer el elemento mayor simplemente se consulta el último elemento del
arreglo.
Nuestra implementación usará un heap principalmente por la eficiencia que tiene para obtener el
valor máximo e insertar nuevos elementos. Un heap ya soporta de manera eficiente las operaciones
Insert, en tiempo O(log N), y Max, en tiempo Θ(1), sólo le falta la operación Extrac-Max. El
siguiente código muestra una implementación para este método.
✷

1.2. HEAPS 13
Figura 1.8: Ejemplo de la aplicación de Extract-Max sobre un heap.
Heap.Extract-Max()
if π = 0
then error “heap underflow”
m := A[0]
A[0] := A[π − 1]
π := π − 1
Heapify(0)
return m
La idea del algoritmo es intercambiar el último elemento del heap, que es una hoja, con la raíz del
heap. Al hacer esto, posiblemente la propiedad de heap es violada por la nueva raiz, pero es tal que
cada uno de sus subárboles cumple con ser un heap válido, por lo tanto es factible aplicar Heapify
para arreglar la deficiencia en la raíz. La figura 1.8 muestra un ejemplo de este procedimiento aplicado
a un heap particular.
Ejercicios
1. Demuestre que el procedimiento Max de un heap efectivamente retorna el valor máximo
almacenado en el heap.
2. Demuestre que el procedimiento Heapify es correcto. Calcule usando relaciones de recurrencia
la complejidad del procedimiento.
3. Demuestre que en un árbol binario completo con N nodos, la cantidad de nodos de altura h
es exactamente ⌈N/2 h+1 ⌉.
4. El procedimiento Build-Heap hace Heapify desde las hojas del árbol (arreglo) hasta la raiz.
Dado que las hojas de un árbol ya cumplen la propiedad de heap no es necesario hacer Heapify
sobre ellas. Mejore el procedimiento Build-Heap para que este no tome en cuenta las hojas.
Discuta si su mejora aumenta la eficiencia asintótica del algoritmo (si se mejora o no el tiempo
O(N) del algoritmo original).

14 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
Figura 1.9: Un elemento componente de una lista doblemente ligada
1.3. Listas Doblemente Ligadas
Una lista doblemente ligada es una estructura en la que los elementos están dispuestos en un
orden lineal, y que soporta las tres operaciones elementales sobre conjuntos dinámicos (aunque no
siempre de manera eficiente). Cada elemento en una lista es un objeto que posee un atributo clave
y punteros para plasmar la estructura de la lista. Si x es un objeto en la lista:
x.k representa al atributo clave
x.next representa al objeto siguiente en la lista
x.prev representa al objeto anterior en la lista
La figura 1.9 muestra un objeto con estos atributos. La lista completa se representa entonces
simplemente por un puntero a su primer objeto, que llamaremos head cuyo valor inicial será nil,
así la lista puede implementarse como:
List:
head := nil
Operaciones Básicas
La búsqueda en una lista doblemente ligada se hace en forma lineal. El siguiente es una posible
implementación para buscar un elemento con clave k en una lista, entrega el primer elemento que
tiene clave k, o nil si ningún elemento tiene esa clave. Toma tiempo Θ(N) en el peor caso si la lista
tiene N elementos.
List.Search(k)
x := head
while x ≠ nil ∧ x.k ≠ k
do x := x.next
return x
Inicialmente en una lista, su atributo head apunta a nil lo que significa que la lista se encuentra
vacía. Para poder agregar elementos a una lista se necesita de un procedimiento de inserción. El
siguiente procedimiento inserta un nuevo elemento a una lista.

1.3. LISTAS DOBLEMENTE LIGADAS 15
Figura 1.10: Listas con centinelas
List.Insert(x)
x.next := head
if head ≠ nil
then head.prev := x
head := x
x.prev := nil
El tiempo de ejecución de Insert es O(1) en el pero caso.
El siguiente procedimiento elimina un elemento x desde una lista. En el se supone que x es un
puntero directo al objeto que se quiere eliminar. Si en vez del puntero, sólo se tiene la clave del
objeto, este debe ser primero encontrado en la lista y luego eliminado.
List.Delete(x)
if x.prev ≠ nil
then x.prev.next := x.next
else head := x.next
if x.next ≠ nil
then x.next.prev := x.prev
El tiempo de ejecución de Delete es O(1) en el peor caso.
Centinelas
Si en el código de Delete pudiésemos ignorar las condiciones de borde, la implementación
resultaría en algo como
List.Delete(x)
x.prev.next := x.next
x.next.prev := x.prev
que no funcionaría por ejemplo en el caso de que la lista se encontrara vacía.
Un centinela es un objeto tonto que nos sirve para simplificar las condiciones de borde en una
lista (en general en una estructura ligada por punteros). Supongamos que a nuestra lista le agregamos
un objeto nil que representa a nil pero tiene todos los atributos de los otros objetos de la lista. La

16 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
idea de este objeto es que se posicione entre el primer y último elemento de la lista, de manera tal que
el primer elemento lo apunte mediante su atributo prev y el último lo apunte mediante su atributo
next. El objeto nil será por su parte tal que su atributo next apunte al primer elemento de la lista
y su atributo prev apunte al último elemento de la lista. La figura 1.10 muestra ejemplos de listas
adicionadas con un centinela. Nótese que el objeto nil no representa información alguna, sólo se
usará como reemplazo a una referencia a nil, por ejemplo, anteriormente el puntero prev del primer
elemento de la lista apuntaba a nil, ahora lo hace al objeto nil. Dado que ahora nil.next apunta al
primer elemento de la lista, podemos incluso prescindir del atributo head. Con estas consideraciones
una lista vacía contendrá sólo al objeto nil y tal que inicialmente tanto los puntero nil.prev como
nil.next apunten el mismo nil. Nuestra nueva estructura lista será:
List:
nil :
k := nil
next := nil
prev := nil
Con la adición del centinela nil el método Delete anterior funciona sin problemas para eliminar
un objeto de la lista. Nótese como ya no son necesarias las condiciones de borde gracias al centinela.
Para buscar en la lista con centinela usamos el procedimiento Search que funciona como antes
pero se deben cambiar las referencias a head que ya no existe.
List.Search(k)
x := nil.next
while x ≠ nil ∧x.k ≠ k
do x := x.next
return x
Al igual que el nuevo procedimiento Delete, el procedimiento Insert se puede hacer de manera
muy simple.
List.Insert(x)
x.next := nil.next
nil.next.prev := x
nil.next := x
x.prev := nil
Los centinelas muy difícilmente disminuyen la eficiencia asintótica de un procedimiento, ellos se
usan generalmente para hacer los códigos más simples. No deben ser usados indiscriminadamente
ya que, a pesar de no tener un significado como elemento de la estructura, necesitan de espacio de
almacenamiento.
Ejercicios
1.

1.4. REPRESENTACIÓN DE ÁRBOLES 17
1.4. Representación de Árboles
Para representar un árbol, generalmente usaremos una estructura de nodo que contendrá un
valor clave que llamaremos k y uno o más punteros a otros nodos del árbol. Cuántos punteros y a
qué nodos del árbol apunten, variará dependiendo del tipo de árbol y su implementación. Un árbol lo
representaremos simplemente a partir de un puntero a su raíz, un nodo distinguido que llamaremos
root el que inicialmente apuntará a nil.
Tree:
root := nil
Árboles Binarios
Si x es un nodo en un árbol binario, el contendrá los siguientes atributos además de la clave:
x.left que apuntará al hijo izquierdo de x
x.right que apuntará al hijo derecho de x
x.p que apuntará al padre de x
Si para algún objeto x se tiene que x.p = nil entonces x es la raíz del árbol. Si para algún objeto x
tanto x.left como x.right son nil entonces x es una hoja del árbol.
El siguiente es una posible implementación para una búsqueda sobre un árbol binario. El método
Tree-Search es recursivo y recibe como parámetro la clave k del objeto que se busca y un puntero
x a un nodo del árbol. Tree-Search entonces busca el objeto con clave k en el subárbol con raíz
en x, retorna el objeto si es que lo encuentra o nil si el objeto no existe en el subárbol.
Tree-Search(k,x)
if x = nil ∨ x.k = k
then return x
l := Tree-Search(k,x.left)
if l ≠ nil
then return l
r := Tree-Search(k,x.right)
if r ≠ nil
then return r
return nil
La llamada inicial sería entonces Tree-Search(k,T.root) para buscar un nodo con clave k en un
árbol T. El tiempo de ejecución para Tree-Search es Θ(N) en el peor caso si el árbol tiene N
nodos.
Los procedimientos de inserción y eliminación de elementos desde árboles binarios dependerán
mucho de la aplicación en la que se estén utilizando y de las políticas que se usen para determinar,
por ejemplo, donde debe ir a parar un nuevo nodo en el árbol.

18 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
Figura 1.11: Un árbol estructurado usando la represetación de hijo–izquierdo, hermano–derecho.
Árboles de Ramificación Ilimitada
La forma de implementación de un árbol binario puede extenderse para cualquier clase de árbol
en el que se conozca a priori la cantidad máxima de hijos que un nodo puede tener, sólo extendemos el
objeto nodo para que tenga tantos punteros como hijos máximos puede tener en el árbol. El problema
surge cuando nos encontramos con árboles en los que no podemos saber a priori la cantidad de hijos
que un nodo puede llegar a tener. Incluso si supiéramos la cantidad máxima de hijos pero esta es
muy grande, una implementación tipo árbol binario nos haría desperdiciar una importante cantidad
de memoria.
Afortunadamente existe una forma inteligente de usar una estructura tipo árbol binario (con
sólo tres punteros) que nos soluciona este problema. La representación se llama hijo–izquierdo,
hermano–derecho. En nuestro árbol, cada nodo x contendrá además de la clave los siguientes
atributos:
x.p que apunta al nodo padre de x en el árbol
x.left-child que apunta al hijo de más a la izquierda de x
x.right-sibling que apunta al hermano de x que está inmediatamente a su derecha.
Con esta implementación, x.left-child = nil si x no tiene ningún hijo, y x.right-sibling = nil
si x es el hijo de más a la derecha de su padre. La figura 1.11 muestra un ejemplo de un árbol
estructurado de la forma mencionada.
El siguiente procedimiento busca dentro de un árbol con la representación hijo–izquierdo hermano–
derecho un elemento con clave k, en el subárbol con raíz en x.
Tree-Search(k,x)
if x = nil ∨ x.k = k
then return x
y := Tree-Search(k,x.left-child)
if y ≠ nil
then return y
z := Tree-Search(k,x.right-sibling)
if z ≠ nil
then return z
return nil

1.4. REPRESENTACIÓN DE ÁRBOLES 19
La llamada inicial entonces para buscar un elemento con clave k en un árbol T es Tree-Search(k,T.root).
El tiempo de ejecución para Tree-Search es Θ(N) en el peor caso si el árbol tiene N nodos.
Ejercicios
1. Escriba procedimientos que muestren todos los valores de las claves almacenadas en un árbol
binario siguiendo cada una de las siguientes reglas:
a) El valor del padre debe imprimirse siempre antes que los dos hijos.
b) El valor de los hijos debe imprimirse siempre antes que el del padre.
c) El valor del padre debe imprimirse después del hijo izquierdo pero antes que el hijo
derecho.
En cada caso, su procedimiento debe tardar O(N) donde N es la cantidad de elementos
almacenados en el árbol.
2. Escriba procedimientos que, dado un árbol almacenado usando la representación hijo–izquierdo
hermano–derecho, imprima todos los valores de sus claves siguiendo cada una de las siguientes
reglas:
a) El valor del padre debe imprimirse antes que todos sus hijos los que deben imprimirse de
izquierda a derecha.
b) El valor del padre debe imprimirse después que todos sus hijos los que deben imprimirse
de derecha a izquierda.
En cada caso, su procedimiento debe tardar O(N) donde N es la cantidad de elementos
almacenados en el árbol.
3. Escriba un procedimiento Search(k,x) para buscar en un árbol almacenado con la representación
de hijo–izquierdo hermano–derecho, pero que haga sólo una llamada recursiva.

20 CAPÍTULO 1. ESTRUCTURAS DE DATOS SIMPLES
1.5. Implementación de Punteros y Objetos
1.6. Definición Algebráica de una Estructura de Datos

Capítulo
2
Algoritmos de Ordenación
Es mucho más fácil, y rápido que es lo que realmente nos importa, operar la información cuando
esta se encuentra almacenada siguiendo cierto orden. Por ejemplo, cuando tenemos una lista ordenada
de n elementos, la búsqueda de un elemento particular puede hacerse de manera tan eficiente como
O(log n), usando búsqueda binaria. Este capítulo está dedicado al problema de ordenación que se
puede definir de la siguiente manera:
Input: Una secuencia de n elementos S = 〈s 1 ,s 2 ...,s n 〉 (generalemente supondremos que s i ∈ Z).
Output: Una permutación de S (reordenamiento), S ′ = 〈s ′ 1,s ′ 2,...,s ′ n〉 tal que s ′ 1 ≤ s ′ 2 ≤ · · · ≤ s ′ n.
Generalmente la secuencia de input la representaremos como un arreglo de n elementos, sin embargo
en algunas aplicaciones puede estar representada usando cualquier otra estructura lineal, como por
ejemplo una lista ligada.
Es importante notar que en pocas aplicaciones reales estaremos interesados en ordenar números,
entonces debemos pensar que lo que ordenamos son claves de objetos con datos satélite, por ejemplo
ordenar un grupo de personas por su número de RUT. Cuando intercambiamos un RUT de posición,
lo que realmente estamos haciendo es intercambiar todos los datos de la persona. Si en alguna
aplicación los datos satélites son demasiados, entonces no los moveremos todos cuando movamos su
clave, sólo moveremos punteros a un objeto que los contenga. Por la discusión anterior, al estudiar el
problema de ordenación, asumiremos siempre que el input es simplemente una secuencia de números.
El traspaso desde un algoritmo que ordene números a otro que ordene objetos más grandes (o con
mayor significado) debiese no presentar demasiado problema.
Como observación final, en general cuando analicemos algoritmos de ordenación, nos interesará
saber cuántas comparaciones entre elementos y cuantas asignaciones se realizaron en total.

22 CAPÍTULO 2. ALGORITMOS DE ORDENACIÓN
Figura 2.1: Ejemplo de ejecución de Insert-Sort
2.1. Algoritmos Simples de Ordenación
Comenzaremos el capítulo estudiando varios algoritmos de ordenación. En general ellos se asemejan
mucho a los métodos que una persona usa para ordenar objetos. Supondremos en cada caso
que lo que se quiere ordenar es un arreglo A[0..n − 1] de n elementos.
Ordenación por Inserción
El algoritmo de ordenación por inserción utiliza la siguiente estrategia: Mantiene la parte inicial
del arreglo ordenada, digamos los valores A[0..j −1] y en la siguiente iteración inserta el valor A[j]
en la posición que le corresponde:
Insert-Sort(A)
for j := 1 to n − 1
do k := A[j]
i := j − 1
while i ≥ 0 ∧ A[i] > k
do A[i + 1] := A[i]
i := i − 1
A[i + 1] := k
La figura 2.1 muestra una ejecución de ejemplo de este algoritmo para un arreglo en particular. No
es difícil demostrar que en el peor caso Insert-Sort toma tiempo O(n 2 ). Un punto interesante es
que el mejor caso de Insert-Sort ocurre cuando el arreglo se encuentra ordenado, en ese caso el
tiempo es O(n).

2.1. ALGORITMOS SIMPLES DE ORDENACIÓN 23
Figura 2.2: Ejemplo de ejecución de Select-Sort
Ordenación por Selección
El algoritmo de ordenación por selección utiliza la siguiente estrategia: Mantiene la parte inicial
del arreglo ordenada, digamos los valores A[0..j] y en la siguiente iteración selecciona el menor de
los valores en A[j + 1..n − 1] y lo intercambia con A[j]:
Select-Sort(A)
for j := 0 to n − 2
do k := j
for i := j + 1 to n − 1 ✄ Después de este ciclo
do if A[i] < A[k] ✄ k es el índice del menor
then k := i ✄ elemento de A[j + 1..n − 1].
intercambia(A[j],A[k])
La figura 2.2 muestra una ejecución de ejemplo de este algoritmo para un arreglo en particular. Al
igual que Insert-Sort, en el peor caso Select-Sort toma tiempo O(n 2 ). Una diferencia importante
es que Select-Sort no distingue entre casos favorables, para cualquier arreglo la cantidad de tiempo
que le toma es O(n 2 ). Ahora, si se quiere obtener un dato exacto, por ejemplo acerca del número de
comparaciones o asignaciones, Select-Sort sí hace diferencias dependiendo de cómo se encuentren
inicialmente los datos.
Ordenación por Mezcla
La ordenación por mezcla se basa en la estrategia dividir para conquistar. Primero divide el arreglo
A en dos, ordena recursivamente cada uno de las partes de A y luego las mezcla. El procedimiento
debe entonces recibir el arreglo y un par de índices que delimitan los bordes de la ordenación. Con
estas consideraciones el código resulta:

24 CAPÍTULO 2. ALGORITMOS DE ORDENACIÓN
Merge-Sort(A,p,r)
if p < r
then q := ⌊ ⌋
p+r
2
Merge-Sort(A,p,q)
Merge-Sort(A,q + 1,r)
Merge(A,p,q,r)
El procedimiento Merge toma un arreglo A y tres índices p ≤ q < r, supone que A[p..q] y
A[q + 1..r] están ambos ordenados y mezcla sus valores de manera tal que al finalizar A[p..r]
está ordenado. Esto se puede hacer en tiempo lineal con respecto a r −p (o sea el largo de la porción
que se quiere mezclar) y su implementación se deja como ejercicio. La propiedad más importante de
un procedimiento que mezcle en tiempo proporcional a r−p es que obligatoriamente necesitará de un
arreglo auxiliar para poder realizar la mezcla, lo que diferencia este algoritmo de los dos anteriores
que sólo utilizaban el mismo arreglo para ordenar.
Para calcular la complejidad de Merge-Sort usaremos relaciones de recurrencia. Supongamos
que designamos por T(n) a la complejidad de tiempo (cantidad de operaciones) que le toma a
Merge-Sort ordenar un arreglo de tamaño n. No es difícil notar que T(n) debe cumplir la siguiente
ecuación:
( n
)
T(n) = 2T + c · n (2.1)
2
ya que para ordenar el arreglo de tamaño n primero deberá ordenar cada una de las mitades del
arreglo para finalmente mezclarlas. En ordenar cada mitad la cantidad de tiempo que tarda es T ( )
n
2
y en mezclarlos toma Θ(n), que hemos representado por el término c·n, con c una constante. El caso
base de la relación de recurrencia es cuando el arreglo tiene tamaño 1, es este caso ya que T(1) es
Θ(1), diremos que T(1) = c para alguna constante c. Para desarrollar la anterior relación haremos
un cambio de variables que nos simplificará los cálculos, diremos que n = 2 k para algún k, entonces
T(n) = T(2 k ) y desarrollando obtenemos:
T(2 k ) = 2T(2 k−1 ) + c · 2 k
= 2(2T(2 k−2 ) + c · 2 k−1 ) + c · 2 k
= 2 2 T(2 k−2 ) + c · 2 k + c · 2 k
= 2 2 (2T(2 k−3 ) + c · 2 k−2 ) + c · 2 k + c · 2 k
= 2 3 T(2 k−3 ) + c · 2 k + c · 2 k + c · 2 k
.
= 2 i T(2 k−i ) + i · c · 2 k
.
= 2 k T(1) + k · c · 2 k
= c · 2 k + c · k2 k
= c · (2 k + k2 k ).
Ahora, dado que habíamos hecho el cambio n = 2 k (y por lo tanto k = log 2 n) obtenemos
T(n) = c · (n + nlog 2 n)
De donde concluimos finalmente que T(n) es Θ(nlog n). Una forma alternativa de obtener este
resultado de complejidad para Merge-Sort es usando la técnica de árboles de recursión que se
muestra en la figura 2.3.

2.1. ALGORITMOS SIMPLES DE ORDENACIÓN 25
Figura 2.3: Árbol de recursión para la complejidad de Merge-Sort.
Muchas veces nos encontraremos con la necesidad de calcular complejidades de algoritmos recursivos,
el siguiente teorema nos ayuda con una fórmula general que servirá en casi todos los casos
que veremos durante el curso.
Teorema 2.1.1. Sea T(n) una función tal que cumple con la siguiente relación de recurrencia:
( n
)
T(n) = aT + f(n)
b
donde f(n) es una función en Θ(n log b a ) y tal que T(1) es Θ(1), entonces se cumple que T(n) es
Θ(n log b a log n).
Es importante notar que Merge-Sort es el primer algoritmo que estudiamos que tarda menos
de Θ(n 2 ) en el peor caso, Merge-Sort tarda Θ(nlog n) en el peor caso, lo que es un gran avance.
El mayor (e insalvable) problema de Merge-Sort es que necesita de mucha memoria adicional para
poder ordenar los números (específicamente en la tarea de mezcla), necesita tanto espacio adicional
como números tenga que ordenar.
Ejercicios
1. Implemente el procedimiento Rec-Insert-Sort(A,i) que ordene el arreglo A usando la misma
estrategia que Insert-Sort pero cambiando una iteración por una llamada recursiva. El
parámetro i indica que lo que se quiere ordenar es la porción A[0..i] del arreglo, así la llamada
inicial debiera ser Rec-Insert-Sort(A,n − 1).
2. Implemente el procedimiento Rec-Select-Sort(A,i) que ordene el arreglo A usando la misma
estrategia que Select-Sort pero cambiando una iteración por una llamada recursiva. El
parámetro i indica que lo que falta por ordenar es la porción A[i..n − 1] del arreglo, así la
llamada inicial debiera ser Rec-Select-Sort(A,0).
✷

26 CAPÍTULO 2. ALGORITMOS DE ORDENACIÓN
3. Implemente el método Merge(A,p,q,r) que mezcla, en tiempo lineal con respecto a r −p, las
porciones A[p..q] y A[q + 1..r] suponiendo que ambas están ordenadas y deja el resultado en
A[p..q].
2.2. Heapsort
En esta sección veremos cómo usar un heap para ordenar de manera eficiente un arreglo mediante
el método Heap-Sort. La idea principal será aprovechar el hecho de que en un heap, el elemento
de mayor valor se encuentra en la raíz y que dado que tenemos un heap deficiente en una de
sus posiciones, arreglarlo se puede hacer de manera muy eficiente usando Heapify. Inicialmente
Heap-Sort creará un heap a partir de un arreglo arbitrario. Ahora, dado que el mayor elemento
del heap se encuentra en la raíz, podemos insertar este elemento directamente donde le corresponde
en el arreglo, o sea, al final. En particular lo que se hará es reemplazar el elemento mayor por el
último en el arreglo y luego arreglar un posible problema que haya quedado en la raíz, suponiendo
ahora que el heap tiene un elemento menos, para posteriormente repetir el proceso. Siguiendo estas
ideas, el código de Heap-Sort es:
Heap-Sort(A)
H := Build-Heap(A)
N := H.π
for i := N − 1 downto 1
do intercambia(H.A[0],H.A[i])
H.π := H.π − 1
H.Heapify(0)
Finalente el arreglo A de los elementos del heap H contiene los valores ordenados.
¿Por qué Heap-Sort funciona? Hasta ahora nos hemos preocupado de estudiar algoritmos de
ordenación en cuanto a su complejidad y sólo de manera intuitiva hemos argumentado por qué efectivamente
ordenan el arreglo. A modo de ejemplo, presentamos una demostración formal de la
correctitud de Heap-Sort en el siguiente teorema.
Teorema 2.2.1. Heap-Sort es correcto, es decir, después de la llamada Heap-Sort(A) el arreglo
A se encuentra efectivamente ordenado.
Demostración. Como la mayoría de las demostraciones de corrección de programas, la estrategia
a usar será inducción, además supondremos que tanto Build-Heap como Heapify son correctos.
Primero estableceremos una propiedad que se cumple en todo momento de ejecución del algoritmo.
La propiedad es la siguiente: después de cada iteración del loop principal se cumple que:
1. A[i..N − 1] está ordenado,
2. A[0..i − 1] cumple la propiedad de heap (es un heap), y
3. A[0..i − 1] ≤ A[i..N − 1], es decir cada elemento en A[0..i − 1] es menor que todos los
elementos de A[i..N − 1].
Si demostramos que esta propiedad se cumple en toda iteración, entonces cuando el algoritmo termina
tenemos que i = 1 y que por lo tanto, por (1) A[1..N−1] está ordenado y por (3) A[0] ≤ A[1..N−1]
por lo que finalmente A[0..N − 1] está ordenado.

2.2. HEAPSORT 27
Lo primero es notar que i decrece, por lo que no podemos hacer inducción en i. Demostraremos
esta propiedad entonces por inducción en la cantidad de iteraciones del loop, que llamaremos n.
Note que la relación directa entre n e i es n = N − i.
B.I. Si n = 0 ⇒ i = N, o sea antes de empezar el ciclo, sabemos que A cumple la propiedad de heap
ya que se ejecutó Build-Heap, luego se cumple (2). Ahora, tanto (1) como (3) se cumplen ya
que los índices quedan fuera del arreglo (no hay nada que demostrar).
H.I. Supongamos que se cumple para n (o equivalentemente para i = N − n), o sea que luego del
paso n–ésimo de la iteración las propiedades (1), (2) y (3) son ciertas, es decir:
1. A[N − n..N − 1] está ordenado,
2. A[0..N − n − 1] cumple la propiedad de heap, y
3. A[0..N − n − 1] ≤ A[N − n..N − 1].
T.I. Analicemos ahora el siguiente paso de la iteración, o sea la iteración n+1, lo que querría decir
que i = N −(n+1). Por la H.I. (2) sabemos que A[0] ≥ A[0..N −n−1] ya que A[0..N −n−1]
cumple la propiedad de heap, y además por (3) sabemos que A[0] ≤ A[N − n..N − 1], por lo
que al intercambiar A[0] con A[N − (n + 1)] = A[N − n − 1] se tiene que A[N − n − 1..N − 1]
está ordenado y que A[0..N − n − 2] ≤ A[N − n − 1..N − 1]. Ahora el cambio pudo haber
hecho que A[0..N − n − 2] dejara de cumplir la propiedad de heap. Hay que notar que justo
antes de la llamada a Heapify el valor de π cumple con π = i = N −n−2, por lo que luego de
la llamada a Heapify, estaremos seguros que A[0..N − n − 2] cumple la propiedad de heap.
Finalmente hemos demostrado que:
- A[N − (n + 1)..N − 1] está ordenado,
- A[0..N − (n + 1) − 1] cumple la propiedad de heap, y
- A[0..N − (n + 1) − 1] ≤ A[N − (n + 1)..N − 1].
Por inducción se sigue que la propiedad se cumple para toda iteración del loop principal.
Finalmente cuando el loop termina, tenemos que i = 1, o sea que n = N − 1, de donde se concluye
(reemplazando n = N −1 en (1) y (3)) que después de la última iteración A[0..N −1] está ordenado.
Complejidad de Heapsort
Para analizar la complejidad de Heap-Sort lo primero que notamos es que se ejecuta una vez
el procedimiento Build-Heap y que el procedimiento Heapify se ejecuta Θ(N) veces. Dado que
Build-Heap toma tiempo Θ(N) y que Heapify toma tiempo Θ(log N) cuando se ejecuta desde la
raíz de un heap con N elementos, podemos asegurar que Heap-Sort toma tiempo O(N+N log N) =
O(N log N) en el peor caso. ¿Podemos dar una cota más ajustada como lo hicimos en el caso de
Build-Heap? La respuesta esta vez es no. Un argumento a favor para intentar encontrar una cota
más ajustada es el hecho de que Heapify no se ejecuta siempre sobre un heap de N elementos, de
hecho, en cada iteración se disminuye el valor de π lo que nos dice que en cada iteración Heapify
se ejecuta sobre un heap cada vez más pequeño. Un argumento muy fuerte en contra de intentar
✷

28 CAPÍTULO 2. ALGORITMOS DE ORDENACIÓN
encontrar una cota más ajustada lo daremos en la sección 2.4. Por ahora daremos las pautas de la
demostración de que Heap-Sort toma tiempo Θ(N log N) en el peor caso y que por lo tanto la cota
ya es ajustada.
En un árbol binario completo, la cantidad de hojas que hay a profundidad 1 p es exactamente 2 p ,
luego, dado que Heapify toma tiempo proporcional a la altura del heap en el peor caso, tenemos
que el tiempo total de Heap-Sort está dado por la sumatoria:
Θ(N) + 2 P Θ(P) + 2 P −1 Θ(P − 1) + 2 P −2 Θ(P − 2) + · · · + 2 1 Θ(1) + 2 0 Θ(0) = Θ(N) +
= Θ
(
N +
)
P∑
2 p p
p=0
P∑
2 p Θ(p)
con P la profundidad total del árbol. Ahora, la sumatoria interna cumple la siguiente desigualdad:
(P − 1)2 P+1 ≤
P∑
2 p p ≤ P2 P+1 .
p=0
La demostración de esta desigualdad se puede hacer por inducción en P y se deja como ejercicio
(ejercicio 3). Dado que el heap es un árbol semicompleto, sabemos que P es aproximadamente log 2 N
por lo que el lado izquierdo de la desigualdad se acota de la siguiente manera
2 · (log 2 N − 1) · 2 log 2 N ≤
P∑
2 p p
p=0
p=0
(2.2)
de donde obtenemos que
P∑
2N log 2 N − 2N ≤ 2 p p
p=0
de donde resulta que la sumatoria ∑ P
p=0 2p p es Ω(N log N). Reemplazando este resultado en nuestro
cálculo inicial 2.2 obtenemos que Heap-Sort tiene complejidad
Θ(N + N log N) = Θ(N log N).
Ejercicios
1. Encuentre una notación O lo más ajustada posible, para el tiempo de ejecución de Heap-Sort
cuando el arreglo A se encuentra ya ordenado.
2. Encuentre una notación O lo más ajustada posible, para el tiempo de ejecución de Heap-Sort
cuando el arreglo A se encuentra ordenado al revés, o sea, de mayor a menor.
1 ¡No confundir profundidad con altura!

2.3. QUICKSORT 29
3. Demuestre que para todo P mayor o igual a 0 se cumple
2.3. Quicksort
(P − 1)2 P+1 ≤
P∑
2 p p ≤ P2 P+1 .
En esta sección estudiaremos el algoritmo de ordenación Quick-Sort que es uno de los algoritmos
más eficientes para ordenar en un caso promedio (real). Al igual que Merge-Sort, Quick-Sort
usa una estrategia del tipo dividir para conquistar, por lo que es natural plantearlo como un procedimiento
recursivo. La estrategia para ordenar el arreglo A[p..r] es la siguiente:
p=0
Divide el arreglo A[p..r] usando un índice q, para obtener A[p..q] y A[q + 1..r], tal que se
cumpla la propiedad
A[p..q] ≤ A[q + 1..r]. (2.3)
Ordena recursivamente cada uno de las partes A[p..q] y A[q + 1..r].
No necesita mezclar ya que luego de ordenar recursivamente A[p..q] y A[q + 1..r] por la
propiedad (2.3) anterior, el arreglo A[p..r] resulta ordenado.
Debiera quedar claro entonces, dado que no se deben mezclar las soluciones a los subproblemas,
que la mayor parte del trabajo se gastará en encontrar el índice q para particionar el arreglo A de
manera de cumplir la propiedad (2.3). Siguiendo esta estrategia, el código para Quick-Sort es:
Quick-Sort(A,p,r)
if p < r
then q := Partition(A,p,r)
Quick-Sort(A,p,q)
Quick-Sort(A,q + 1,r)
La llamada inicial entonces para ordenar el arreglo A es Quick-Sort(A,0,n − 1).
El procedimiento Partition(A,p,r) encuentra un índice q, p ≤ q < r, tal que A[p..q] ≤
A[q + 1..r]. Para hacerlo, elige un pivote dentro del arreglo y luego deja en la parte inicial de
A[p..r] sólo elementos que sean menores o iguales al pivote, y en la parte final de A[p..r] sólo
elementos que sean mayores o iguales que el pivote. En la siguiente implementación de Partition
se elige como pivote al primer elemento de A[p..r].
Partition(A,p,r)
x := A[p] ✄ Elige a A[p] como pivote
i := p − 1
j := r + 1
while true
do repeat j := j − 1 while A[j] > x
repeat i := i + 1 while A[i] < x
if i < j
then intercambia(A[i],A[j])
else return j

30 CAPÍTULO 2. ALGORITMOS DE ORDENACIÓN
Figura 2.4: Ejemplo de ejecución de Partition.
Lo que hace Partition es usar dos índices i y j para apuntar la parte inicial y final del arreglo
A[p..r], y establecer x = A[p] como el pivote de la partición. Dentro del loop principal, el índice j es
decrementado mientras A[j] sea mayor que el pivote, y el índice i es incrementado mientras A[i] sea
menor que el pivote. Cuando estas dos propiedades sean violadas, sabemos que A[j] es muy pequeño
para estar en la parte final de A[p..r] y que A[i] es muy grande para estar en la parte inicial de
A[p..r], por lo que ambos valores son intercambiados. El loop termina cuando los índices i y j se
cruzan, entregando j como punto de partición. La figura 2.4 muestra un ejemplo de ejecución del
procedimiento Partition.
Un punto muy importante es que Partition entrega siempre un valor q ≠ r, si en algún caso
entregara q = r, Quick-Sort haría infinitas llamadas recursivas y nunca terminaría. La elección
de A[p] como el pivote es crucial en esta propiedad, de hecho, si en vez se hubiese elegido a A[r]
como pivote hubiese sido posible que Partition entregara q = r (¿cuándo?). El ejercicio 1 le pide
demostrar que Quick-Sort es correcto a partir de suponer que Partition es correcto. El ejercicio 3
le pide demostrar que Partition es correcto.
Complejidad de Quicksort
Primero, no es difícil notar que Partition(A,p,r) toma tiempo lineal con respecto a r − p.
Ahora, llamemos T(n) al tiempo que le toma a Quick-Sort ordenar un arreglo de n elementos.
Dado que Quick-Sort particiona el arreglo en dos y el procedimiento de partición tarda tiempo
lineal con respecto al largo total del arreglo, podemos decir que el tiempo que le toma a Quick-Sort
está regido por la relación de recurrencia
T(n) = T(p) + T(n − p) + c · n (2.4)
T(1) = c
cuando suponemos que el tamaño de una de las particiones producidas por Partition es p. La
complejidad de Quick-Sort dependerá entonces directamente de la calidad de la partición.
Supongamos que la partición se lleva a cabo de manera tal que siempre se obtiene una división
del arreglo con sólo un elemento y otra con los n−1 elementos restantes, o sea, p = 1. Reemplazando

2.3. QUICKSORT 31
Figura 2.5: Árbol de recursión para Quick-Sort en el caso de una partición desbalanceada.
en (2.4) obtenemos
T(n) = T(1) + T(n − 1) + c · n
de donde resolviendo obtenemos
T(n) = c + T(n − 1) + c · n
= 2c + T(n − 2) + c · (n − 1) + c · n
= 3c + T(n − 3) + c · (n − 2) + c · (n − 1) + c · n
.
= c · (n − 1) + T(1) + c · 2 + · · · + c · (n − 1) + c · n
= c · (n − 1) + c · ∑n
i=1 i
por lo que T(n) es Θ(n 2 ), o sea, en el caso de que la partición produzca siempre una región de
largo 1 y otra de largo n − 1, Quick-Sort se comporta asintóticamente como el pero caso de
Insert-Sort y Select-Sort. El árbol de recursión para este caso se muestra en la figura 2.5. Se
puede demostrar, no lo haremos aquí, que este es el peor comportamiento posible para Quick-Sort.
Un punto interesante de observar es que este patrón de particiones se obtienen cuando el arreglo de
entrada se encuentra ya ordenado.
Supongamos ahora que la partición se produce de manera tal que siempre deja regiones del mismo
largo, o sea, dos regiones de largo n 2
. Reemplazando en (2.4) obtenemos
( n
) ( n
) ( n
)
T(n) = T + T + c · n = 2T + c · n
2 2 2
que es igual a la ecuación (2.1), por lo que T(n) es Θ(nlog n) en este caso. El árbol de recursión es
el mismo que aparece en la figura 2.3.
Hemos visto un caso malo y uno bueno (comparativamente con los anteriores algoritmos estudiados).
¿Cómo podemos analizar un caso promedio de Quick-Sort? Una posibilidad es pensar que
las particiones se generan siempre con cierta proporción no balanceada que esté entre el caso 1 vs
n − 1 y el caso n 2 vs n 2
. Por ejemplo, supongamos que la partición siempre genera regiones de largo

32 CAPÍTULO 2. ALGORITMOS DE ORDENACIÓN
n
c · n
log 10 n
n
10
9n
10
c · n
log 10/9 n
n
100
9n
100
9n
100
81n
100
c · n
1
81n
1000
729n
1000
c · n
≤ c · n
1
≤ c · n
Θ(nlog n)
Figura 2.6: Árbol de recursión para Quick-Sort cuando la partición se produce en relación 9 : 1.
en razón 9 : 1, o sea p = n 10
. Reemplazando en (2.4) obtenemos
( ( ) n 9n
T(n) = T + T + c · n.
10)
10
El árbol de recursión para este caso se muestra en la figura 2.6. En él podemos notar que cada
nivel del árbol tiene un costo de c · n (por la suma de la aplicación de Partition a cada porción
del arreglo) hasta una condición de borde que se alcanza cuando las llamadas recursivas de más a
la izquierda dejan de suceder, o sea, cuando estas se hagan sobre arreglos de tamaño 1. Esto pasa
a profundidad log 10 n en la parte izquierda del árbol. Desde ese punto en adelante, cada nivel del
árbol tendrá costo total menor o igual a c ·n. La recursión completa termina a profundidad log 10/9 n
por lo que la suma total del trabajo será Θ(nlog 10/9 n) = Θ(nlog n). No es difícil ver que cualquier
proporción que elijamos, por desbalanceada que esta parezca, nos llevará a concluir que la eficiencia
asintótica de Quick-Sort resulta Θ(nlog n), la diferencia principal estará dada por la constante
escondida que acompaña a nlog n.
Otra forma, mucho más acertada, de obtener una intuición del caso promedio de Quick-Sort
es suponiendo que todas las entradas son igualmente probables de obtener. Si este es el caso, es
muy poco probable que todas las particiones ocurran de la misma forma, todas balanceadas, todas
desbalanceadas, todas en la misma proporción, etc. En un caso promedio Partition generará una
mezcla entre “buenas” y “malas” particiones. Será mucho más acertado suponer entonces que las
buenas y malas particiones se van mezclando en el árbol de recursión. Por simplicidad podemos
suponer que vez por medio se obtiene una buena y una mala partición, es decir, que en una llamada
se obtiene una partición del tipo 1 vs n − 1 y en otra se obtiene una partición del tipo n 2 vs n 2 .
Una porción de este árbol de recursión se muestra en la figura 2.7. En ella también se muestra
como un árbol de recursión con malas y buenas particiones intercaladas, se puede ver como un árbol
de recursión con sólo buenas particiones. Si se analiza con cuidado este caso se concluye que en él
también el comportamiento asintótico de Quick-Sort resulta ser Θ(nlog n).

2.3. QUICKSORT 33
n
Θ(n)
Θ(n)
1 n − 1
n−1
2
n−1
2
⇐⇒
n
n−1
2
+ 1
n−1
2
Figura 2.7: Porción del árbol de recursión para Quick-Sort cuando las particiones se producen
intercalando buenas y malas (izquierda), y cómo esta puede representarse por una porción de un
árbol con sólo particiones buenas (derecha).
Quicksort Aleatorio
Hemos entregado evidencia acerca de que, si todas las posibles entradas son igualmente probables,
entonces Quick-Sort tiene un buen comportamiento esperado, Θ(nlog n). ¿Qué tan razonable es la
suposición de que todas las entradas son igualmente probables? Depende demasiado de la aplicación.
Por ejemplo, suponga una aplicación que ordena datos de personas por fecha de nacimiento, si ocurre
el caso de que los datos se encontraban inicialmente ordenados por RUT, Quick-Sort tendrá un mal
comportamiento ¿por qué? El caso peor ocurre si quien entrega la entrada es un adversario. Si él sabe
que estamos utilizando Quick-Sort para ordenar el arreglo puede forzar un mal comportamiento.
Una alternativa para solucionar estos problemas es, en vez de suponer que todas las entradas
son igualmente probables, imponer que todas lo sean. Esto se puede lograr, por ejemplo, haciendo
permutaciones aleatorias de los elementos antes de comenzar a ordenarlos. Entonces Quick-Sort
podría obtener un mejor comportamiento esperado si antes de comenzar a ordenar los valores, se
asegura de que estos estén suficientemente “desordenados”, desordenados en el sentidos de que no
dependan de una aplicación en particular. Importante es notar que esta modificación no mejora el
peor comportamiento de Quick-Sort, de hecho podría tenerse tan mala suerte que en el proceso
de “desorden” el arreglo quede ya ordenado, en cuyo caso se obtendrá de todas maneras un mal
comportamiento. Lo que si estamos seguros que se logra es independizarse de la fuente de datos
de entrada, la probabilidad de obtener un mal desempeño ya no dependerá de la aplicación o de si
un adversario es quién provee los datos de entrada.
El siguiente algoritmo Rand-Quick-Sort implementa esta idea llamando al procedimiento
Rand-Partition para realizar la partición.
Rand-Quick-Sort(A,p,r)
if p < r
then q := Rand-Partition(A,p,r)
Rand-Quick-Sort(A,p,q)
Rand-Quick-Sort(A,q + 1,r)

34 CAPÍTULO 2. ALGORITMOS DE ORDENACIÓN
Rand-Partition(A,p,r)
i :=rand(p,r)
intercambia(A[p],A[i])
return Partition(A,p,r)
En esta implementación no se está desordenando el arreglo inicialmente, en cambio, se están tomando
decisiones aleatorias de vez en cuando. Esta decisión aleatoria tiene que ver con la elección del pivote
para realizar la partición. La función rand(p,r) entrega un número entero aleatorio entre p y r.
Ejercicios
1. Demuestre que Quick-Sort es correcto suponiendo que Partirion es correcto, es decir,
demuestre que efectivamente después de la llamada Quick-Sort(A,0,n − 1) sobre un arreglo
de tamaño n, el arreglo queda efectivamente ordenado, suponiendo que la llamada a
Partition(A,p,r) entrega un índice q tal que p ≤ q < r y A[p..q] ≤ A[q + 1..r] después de
la llamada.
2. De una argumentación simple de por qué Partition(A,p,r) toma tiempo lineal con respecto
a r − p.
3. Demuestre que Partition es correcto, es decir, demuestre que la llamada a Partition(A,p,r)
entrega un índice q tal que p ≤ q < r y A[p..q] ≤ A[q + 1..r] después de la llamada.
2.4. Ordenación en Tiempo Esperado Lineal
2.5. Estadísticas de Orden

Capítulo
3
Estructuras de Datos para Diccionarios
(Aquí una pequeña introducción)
3.1. Tablas de Hash
3.2. Árboles Binarios de Búsqueda
3.3. Árboles AVL
3.4. Árboles Rojo–Negro
3.5. SkipLists
3.6. Aumento de una Estructura de Datos
35

36 CAPÍTULO 3. ESTRUCTURAS DE DATOS PARA DICCIONARIOS

Capítulo
4
Estructuras de Datos Externas
(Aquí una pequeña introducción)
4.1. Indexación Secuencial
4.2. Árboles–B
37

38 CAPÍTULO 4. ESTRUCTURAS DE DATOS EXTERNAS

Capítulo
5
Otras Estructuras de Datos
(Aquí una pequeña introducción)
5.1. Estructuras para Conjuntos Disjuntos
5.2. Heaps Binomiales
5.3. Heaps de Fibbonacci
39

40 CAPÍTULO 5. OTRAS ESTRUCTURAS DE DATOS

Capítulo
6
Técnicas Fundamentales de Diseño de Algoritmos
6.1. Analisis Amortizado
6.2. Algoritmos Codiciosos
6.3. Divir para Conquistar
6.4. Programación Dinámica
41

42 CAPÍTULO 6. TÉCNICAS FUNDAMENTALES DE DISEÑO DE ALGORITMOS

Capítulo
7
Algoritmos en Grafos
(Aquí una pequeña introducción)
7.1. Recorridos en Profundidad y Amplitud
7.2. Orden Topológico
7.3. Componentes Fuertemente Conexas
7.4. Árboles de Cobertura de Costo Mínimo
7.5. Caminos más Cortos
7.6. Flujo Máximo en Redes
43

44 CAPÍTULO 7. ALGORITMOS EN GRAFOS

Capítulo
8
Algoritmos sobre Strings
(Aquí una pequeña introducción)
8.1. Pattern Matching
8.2. Pattern Matching de Expresiones Regulares
8.3.
45

46 CAPÍTULO 8. ALGORITMOS SOBRE STRINGS

Capítulo
9
Estructuras y Algoritmos para Computación Gráfica
(Aquí una pequeña introducción)
9.1.
47

48 CAPÍTULO 9. ESTRUCTURAS Y ALGORITMOS PARA COMPUTACIÓN GRÁFICA

Capítulo
10
Introducción a la Complejidad Computacional
(Aquí una pequeña introducción)
10.1. Las clases de problemas P y NP
10.2. Problemas NP-duros y NP-completos
10.3. La clase co-NP
10.4. Más allá de P
10.5. Dentro de P
49

Índice
50