Heaps en java
89
Heaps Ing. Andrea Quan
Transcript of Heaps en java
Heaps
Ing. Andrea Quan
Heaps
Un heap (binario) es una estructura de datos implementada con un arreglo, el cual representa un árbol binario completo.
Heaps
Un heap (binario) es una estructura de datos implementada con un arreglo, el cual representa un árbol binario completo.
¿Qué es un arbol binario completo?
Heaps
Un heap (binario) es una estructura de datos implementada con un arreglo, el cual representa un árbol binario completo.
¿Qué es un arbol binario completo? Un árbol binario completo se define como un árbol
binario en el cual todos sus niveles están completos, excepto posiblemente el último nivel, el cual se va llenando de izquierda a derecha conforme van ingresando los nodos.
COMPLETOS NO COMPLETOS
Arbol binario completo à heap
Cada nodo del árbol corresponde a un elemento en el arreglo el cual guarda el valor del nodo. Esta correspondencia es descrita por las siguientes reglas:
– arreglo[1] es la raíz del árbol – Dado un índice en el arreglo i
• parent (i) = i/2 • left (i) = 2i • right (i) = 2i + 1
Ejemplo
1
16
14 10
8 7 9
2 4
3
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 1
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 1 2
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 1 2 3
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 1 2 3 4
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 1 2 3 4 5
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 1 2 3 4 5 6
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 1 2 3 4 5 6 7
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 1 2 3 4 5 6 7 8
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1 2 3 4 5 6 7 8 9
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1 1 2 3 4 5 6 7 8 9 10
Ejemplo
1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1 1 2 3 4 5 6 7 8 9 10
Heaps
• Existen dos tipos de binary heaps – max heaps – min heaps
• Ambos tipos satisfacen una heap property: – max heaps satisfacen la max heap property – min heaps satisfacen la min heap property
heap property • Max heap property:
Para cada nodo i diferente del padre A[Parent(i)] ≥ A[i]
heap property • Max heap property:
Para cada nodo i diferente del padre A[Parent(i)] ≥ A[i] à Root guarda el mayor elemento
heap property • Max heap property:
Para cada nodo i diferente del padre A[Parent(i)] ≥ A[i] à Root guarda el mayor elemento
• Min heap property: Para cada nodo i diferente del padre
A[Parent(i)] ≤ A[i]
heap property • Max heap property:
Para cada nodo i diferente del padre A[Parent(i)] ≥ A[i] à Root guarda el mayor elemento
• Min heap property: Para cada nodo i diferente del padre
A[Parent(i)] ≤ A[i] à Root guarda el menor elemento
Ejemplo Max Heap
1
16
14 10
8 7 9
2 4
3
Ejemplo Min Heap
11
1
2 3
8 7 9
12 14
10
Manteniendo la max-heap-property
• Algoritmo MAX-HEAPIFY – Este algoritmo sirve para mantener la max-heap-
property – Recibe como parámetros al arreglo A, y un índice i en
el arreglo. – Cuando es llamado este algoritmo se asume que los
subarboles izquierdo y derecho del nodo satisfacen la max-heap-property
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else {
largest = i
}
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
Ejemplo
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1 1 2 3 4 5 6 7 8 9 10
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
i = 1
l =
r =
largest =
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
i = 1
l = 2
r =
largest =
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
i = 1
l = 2
r = 3
largest =
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
i = 1
l = 2
r = 3
largest =
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
i = 1
l = 2
r = 3
largest = 2
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
i = 1
l = 2
r = 3
largest = 2
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
i = 1
l = 2
r = 3
largest = 2
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
4 10
14 7 9
2 8
3
HEAP à 16 4 10 14 7 9 3 2 8 1
i = 1
l = 2
r = 3
largest = 2
MAX-HEAPIFY(A,1)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
4 10
14 7 9
2 8
3
HEAP à 16 4 10 14 7 9 3 2 8 1
i = 2
l = 2
r = 3
largest = 2
MAX-HEAPIFY(A,2)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
4 10
14 7 9
2 8
3
HEAP à 16 4 10 14 7 9 3 2 8 1
i = 2
l = 4
r = 5
largest = 2
MAX-HEAPIFY(A,2)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
4 10
14 7 9
2 8
3
HEAP à 16 4 10 14 7 9 3 2 8 1
i = 2
l = 4
r = 5
largest = 2
MAX-HEAPIFY(A,2)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
4 10
14 7 9
2 8
3
HEAP à 16 4 10 14 7 9 3 2 8 1
i = 2
l = 4
r = 5
largest = 4
MAX-HEAPIFY(A,2)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
4 10
14 7 9
2 8
3
HEAP à 16 4 10 14 7 9 3 2 8 1
i = 2
l = 4
r = 5
largest = 4
MAX-HEAPIFY(A,2)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
4 10
14 7 9
2 8
3
HEAP à 16 4 10 14 7 9 3 2 8 1
i = 2
l = 4
r = 5
largest = 4
MAX-HEAPIFY(A,2)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
4 7 9
2 8
3
HEAP à 16 14 10 4 7 9 3 2 8 1
i = 2
l = 4
r = 5
largest = 4
MAX-HEAPIFY(A,2)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
4 7 9
2 8
3
HEAP à 16 14 10 4 7 9 3 2 8 1
i = 4
l = 4
r = 5
largest = 4
MAX-HEAPIFY(A,4)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
4 7 9
2 8
3
HEAP à 16 14 10 4 7 9 3 2 8 1
i = 4
l = 8
r = 9
largest = 4
MAX-HEAPIFY(A,4)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
4 7 9
2 8
3
HEAP à 16 14 10 4 7 9 3 2 8 1
i = 4
l = 8
r = 9
largest = 4
MAX-HEAPIFY(A,4)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
4 7 9
2 8
3
HEAP à 16 14 10 4 7 9 3 2 8 1
i = 4
l = 8
r = 9
largest = 4
MAX-HEAPIFY(A,4)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
4 7 9
2 8
3
HEAP à 16 14 10 4 7 9 3 2 8 1
i = 4
l = 8
r = 9
largest = 9
MAX-HEAPIFY(A,4)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
4 7 9
2 8
3
HEAP à 16 14 10 4 7 9 3 2 8 1
i = 4
l = 8
r = 9
largest = 9
MAX-HEAPIFY(A,4)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > a[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > a[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
i = 4
l = 8
r = 9
largest = 9
MAX-HEAPIFY(A,4)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
i = 9
l = 8
r = 9
largest = 9
MAX-HEAPIFY(A,9)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
i = 9
l = 18
r = 19
largest = 9
MAX-HEAPIFY(A,9)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
i = 9
l = 18
r = 19
largest = 9
MAX-HEAPIFY(A,9)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
i = 9
l = 18
r = 19
largest = 9
MAX-HEAPIFY(A,9)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
}
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
i = 9
l = 18
r = 19
largest = 9
MAX-HEAPIFY(A,9)
MAX-HEAPIFY(A,i) {
l = LEFT(i)
r = RIGHT(i)
if l ≤ heapsize[A] and A[l] > A[i] {
largest = l
} else { largest = i }
if r ≤ heapsize[A] and A[r] > A[largest] {
largest = r
}
if largest ≠ i {
A[i] A[largest]
MAX-HEAPIFY(A,largest)
}
} FIN
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
MAX-HEAPIFY(A,9)
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
Arbol binario completo à max heap
• Podemos utilizar el algoritmo MAX-HEAPIFY aplicandolo en forma button-up para convertir un arbol binario completo, representado por un arreglo, en un max heap.
• Utilizamos el algoritmo BUILD-MAX-HEAP
BUILD-MAX-HEAP(A) {
heap-size[A] = length[A]
for i = length[A]/2 downto 1 {
MAX-HEAPIFY(A,i)
}
}
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 3
2 16 9
14 8
10
HEAP à 4 1 3 2 16 9 10 14 8 7
10/2 = 5
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 3
2 16 9
14 8
10
HEAP à 4 1 3 2 16 9 10 14 8 7
MAX-HEAPIFY(A,5)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 3
2 16 9
14 8
10
HEAP à 4 1 3 2 16 9 10 14 8 7
MAX-HEAPIFY(A,4)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 3
14 16 9
2 8
10
HEAP à 4 1 3 14 16 9 10 2 8 7
MAX-HEAPIFY(A,4)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 3
14 16 9
2 8
10
HEAP à 4 1 3 14 16 9 10 2 8 7
MAX-HEAPIFY(A,3)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 10
14 16 9
2 8
3
HEAP à 4 1 10 14 16 9 3 2 8 7
MAX-HEAPIFY(A,3)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 10
14 16 9
2 8
3
HEAP à 4 1 10 14 16 9 3 2 8 7
MAX-HEAPIFY(A,2)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
MAX-HEAPIFY(A,2)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 1
4
16 10
14 7 9
2 8
3
HEAP à 4 16 10 14 7 9 3 2 8 1
MAX-HEAPIFY(A,1)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1 1 2 3 4 5 6 7 8 9 10
Heapsort
• El algoritmo de heapsort sirve para ordenar un árbol (arreglo)
• El algoritmo utiliza BUILD-MAX-HEAP para ordenar el árbol (arreglo) ascendentemente.
• Si queremos ordenar descendentemente tendríamos que usar MIN-HEAPIFY y BUILD-MIN-HEAP
HEAPSORT(A) {
BUILD-MAX-HEAP(A)
for i = length[A] downto 2 {
A[1] A[i]
heap-size[A] = heap-size[A] – 1
MAX-HEAPIFY(A,1)
}
}
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 3
2 16 9
14 8
10
HEAP à 4 1 3 2 16 9 10 14 8 7 1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 7
4
1 3
2 16 9
14 8
10
HEAP à 4 1 3 2 16 9 10 14 8 7
BUILD-MAX-HEAP(A)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 1
16
14 10
8 7 9
2 4
3
HEAP à 16 14 10 8 7 9 3 2 4 1
BUILD-MAX-HEAP(A)
heapsize
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
1
14 10
8 7 9
2 4
3
HEAP à 1 14 10 8 7 9 3 2 4 16
A[1] A[10]
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
1
14 10
8 7 9
2 4
3
HEAP à 1 14 10 8 7 9 3 2 4 16
Heapsize[A] - 1
1 2 3 4 5 6 7 8 9 10
heapsize
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
14
8 10
4 7 9
2 1
3
HEAP à 14 8 10 4 7 9 3 2 1 16
MAX-HEAPiFY(A,1)
1 2 3 4 5 6 7 8 9 10
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
1
8 10
4 7 9
2 14
3
HEAP à 1 8 10 4 7 9 3 2 14 16
A[1] A[9]
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
1
8 10
4 7 9
2 14
3
HEAP à 1 8 10 4 7 9 3 2 14 16
Heapsize[A] - 1
heapsize
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
10
8 9
4 7 1
2 14
3
HEAP à 10 8 9 4 7 1 3 2 14 16
MAX-HEAPiFY(A,1)
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
9
8 3
4 7 1
10 14
2
HEAP à 9 8 3 4 7 1 2 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
8
7 3
4 2 1
10 14
9
HEAP à 8 7 3 4 2 1 9 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
7
4 3
1 2 8
10 14
9
HEAP à 7 4 3 1 2 8 9 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
4
2 3
1 7 8
10 14
9
HEAP à 4 2 3 1 7 8 9 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
3
2 1
4 7 8
10 14
9
HEAP à 3 2 1 4 7 8 9 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
2
1 3
4 7 8
10 14
9
HEAP à 2 1 3 4 7 8 9 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
1
2 3
4 7 8
10 14
9
HEAP à 1 2 3 4 7 8 9 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
1
2 3
4 7 8
10 14
9
HEAP à 1 2 3 4 7 8 9 10 14 16
Ejemplo
2
1
4 6 5
3
7
8 9 10 16
1
2 3
4 7 8
10 14
9
HEAP à 1 2 3 4 7 8 9 10 14 16
