Anlisis y Diseo de Algoritmos

Ordenamiento Heapsort y Quicksort

DR. JESS A. GONZLEZ BERNAL

CIENCIAS COMPUTACIONALES
INAOE
 Heaps
2

Un Heap es una estructura de datos binaria

Un arreglo que representa un rbol binario completo
 Heaps
3

Cada nodo es un elemento del arreglo

Almacena el valor en el nodo

rbol completamente lleno, excepto en el ltimo nivel (tal vez)

Arreglo representando el heap

2 atributos
Length[A] # elementos en el arreglo A
Heap-size[A] # elementos en el heap almacenados en arreglo A

Heap-size length[A]
Raz del rbol A[1]
 Heaps
4

Dado el ndice i de un nodo

Parent(i) return floor(i/2)
Left(i) return 2i
Right(i) return (2i + 1)

Propiedad Heap
MAX-HEAP: A[PARENT(i)] A[i]
MIN-HEAP: A[PARENT(i)] A[i]

Altura de un nodo
# arcos de la ruta simple ms larga del nodo a una hoja

Altura del rbol

Altura de la raz
Altura del rbol es (lgn)
 Heaps
5

Manipulacin de heaps
Entrada
Arreglo A y un ndice i
Asume que LEFT(i) y RIGHT(i) son heaps
A[i] puede ser menor que sus hijos
Viola la propiedad de un heap (MAX-HEAP)
Heapify
Mueve A[i] en el heap
El subrbol con raz en el ndice i se convierte en un heap
 Heapify
6

Algoritmo Heapify
Llamada recursiva a Heapify para sus is subrboles, si no
cumplen con la propiedad del heap
 Heapify
7

Heap-size[A] 10
A[2], i = 2 no cumple con la propiedad de un heap (MAX-HEAP)
Heapify
8
 Heapify
9

Tiempo de ejecucin de heapify

En un subrbol de tamao n, con raz en el nodo i
(1), relacin fija entre A[i], A[LEFT(i)], A[RIGHT(i)]
ms
Tiempo de ejecucin de HEAPIFY en un subrbol con
raz en uno de los hijos de i
Tamao de los subrboles de los hijos es a lo ms
2n/3
T(n) T(2n/3) + (1)
Por el caso 2 del mtodo maestro

T(n) = O(lgn)

Alternativa
Caracterizar tiempo de ejecucin de HEAPIFY
sobre un nodo de altura h como: O(h)
 Construccin del Heap
10

Uso de heapify para construir el heap

Los elementos A[(floor(n/2) + 1) n] son hojas del rbol

Orden en que se procesan los nodos garantiza que los

subrboles con raz en los hijos del nodo i son heaps antes de
que HEAPIFY se ejecute en dicho nodo
 Construccin del Heap
11

Algoritmo BuildHeap
Construccin del Heap
12
 Anlisis BuildHeap
13

Cada llamada a HEAPIFY O(lgn), hay O(n)

llamadas
Cuando mucho O(nlgn)
Cota superior pero no justa
Propiedad: En el n-elemento de un HEAP hay a lo ms
n
/ 2 h +1
nodos de altura h
Tiempo de ejecucin de HEAPIFY en nodo altura h O(h)
Costo de BuildHeap
 Anlisis BuildHeap
14

Del resultado anterior obtenemos el tiempo de ejecucin de BuildHeap

lg n lg n
n h
2 h +1 O ( h ) = O
n *1 / 2
h
h =0 h = 0 2

1
Note que x k = , para | x | < 1. La derivada de ambos lados,
k =0 1 x
d k d 1
k 1 1
x = , es igual a kx = 2
.
dx k =0 dx 1 x k =0 (1 x)
Multiplicando ambos lados de la equivalencia por x obtenemos :

kx
kx
h =0 (1 x)
=2
.

En nuestro caso k = h y x = 1/2.

h
1/ 2
Entonces h
= 2
= 2, x = 1 / 2.
h =0 2 (1 1 / 2)
Entonces el tiempo de ejecucin es O(n *1/2 * 2) = O(n).
Algoritmo HeapSort
15
Algoritmo HeapSort
16
 Anlisis de HeapSort
17

BUILD-HEAP: O(n)
for loop: n-1 veces
Intercambio de elementos: O(1)
MAX-HEAPIFY: O(lgn)
Total time: O(nlgn)
Una implementacin buena de QuickSort es mejor
que HeapSort
 Colas con Prioridades (Priority Queues)
18

Utilizar heaps para implementar colas con

prioridades
Priority queue
Estructura de datos para mantener un conjunto S de elementos
Cada elemento tiene un valor asociado llamado llave

Operaciones
Insert(S,x),
inserta x en S, S S {x}
Maximum(S), regresa el elemento de S con llave ms alta
Extract-Max(S), remueve y regresa el elemento de S con llave ms
alta
 Aplicaciones de Priority Queues
19

Colas para calendarizar trabajos en una computadora

compartida
Mantiene la pista de los trabajos y sus prioridades
Cuando termina un trabajo, inicia el trabajo con ms alta
prioridad
Extract-Max

Inserta un trabajo en cualquier momento con Insert

Operaciones para Priority Queues
20
 Tiempo de Ejecucinpara Priority Queues
21

Heap-Extract-MAX O(lgn)
Heap-Insert O(lgn)
Heap-Increase-Key O(lgn)
 QuickSort
22

Sigue estrategia divide y conquista

Divide
Particiona A[pr] en 2 subarreglos, A[pq] y A[q+1r]
Cada elemento de A[pq] cada elemento de A[q+1r]
En esta parte se calcula el ndice q
Conquista
A[pq] y A[q+1r] son recursivamente ordenados
Combina
No se requiere hacer trabajo en esta parte, A[pr] queda ordenado
Algoritmo QuickSort
23
 Algoritmo Partition
24

Existen diferentes algoritmos para particionar

 Algoritmo Partition
25

Gris Claro: particin menor

Gris Oscuro: particin mayor
ltimo elemento: pivote
Blanco: Sin asignar
 Performance de QuickSort
26

Depende de si la particin est o no balanceada

Depende de qu elemento se utiliz para particionar
Particin balanceada
Rpido como MergeSort
Particin no-balanceada
Lento como InsertionSort
 Performance de QuickSort
27

Peor caso en particin (entrada previamente

ordenada)
1 regin con n-1 elementos y otra con 1 elemento
Asume que esto sucede en cada paso del algoritmo

Costo de particionar (n), T(1) = (1)

Recurrencia T(n) = T(n-1) + (n)

n
= ( k ) Serie Aritmtica
n
k =1 1
n k = 2
n(n + 1)
= k k =1

k =1 = ( n 2 )
= ( n 2 )
 Performance de QuickSort
28

Mejor Caso en Particin

Regiones de tamao n/2

Recurrencia T(n) = 2T(n/2) + (n)

Caso 2, teorema maestro T(n) = (nlgn)

 Performance de QuickSort
29

Particionamiento balanceado
Caso promedio ms cerca del mejor caso que del peor

Suponiendo un split en proporcin 9-1 parece muy

desbalanceado
Recurrencia T(n) = T(9n/10) + T(n/10) + n
Vea el rbol de recurrencia en la siguiente lmina
 Performance de QuickSort
30

rbol de recurrencia caso de split balanceado

 Performance de QuickSort
31

Particionamiento balanceado
Cada nivel tiene costo n

Condicin frontera a profundidad log10n = (lgn)

Los niveles tienen un costo de cuando mucho n
La recursin termina a profundidad log10/9n = (lgn)
Costo total de QuickSort = (nlgn)
Para cada split con proporcin constante
 Performance de QuickSort
32

Intuicin para el caso promedio

Partition produce buenos y malos splits
Distribuidos aleatoriamente
Suponga que los buenos y malos alternan (en el rbol)
Bueno splits del mejor caso

Malo splits del peor caso

Tiempo de ejecucin es todava (nlgn)

Con una constante ms grande escondida por la notacin-O
 Comparacin de Algoritmos
33

Algoritmo Peor Caso Promedio Mejor Caso Comentarios

Caso
InsertionSort (n2) (n2) (n)

MergeSort (nlgn) (nlgn) (nlgn) Requiere

Memoria
HeapSort (nlgn) (nlgn) (nlgn) Constantes
Grandes
QuickSort (n2) (nlgn) (nlgn) Constantes
Pequeas