Вы находитесь на странице: 1из 89

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 estn 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 raz del rbol Dado un ndice en el arreglo i
parent (i) = i/2 left (i) = 2i right (i) = 2i + 1

Ejemplo
16 14 8 2 4 1 7 9 10 3

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16
1

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14
1 2

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

7
5

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

7
5

9
6

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

7
5

9
6

3
7

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

7
5

9
6

3
7

2
8

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

7
5

9
6

3
7

2
8

4
9

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

7
5

9
6

3
7

2
8

4
9

1
10

Ejemplo
16 14 8 2 4 1 7 9 10 3

HEAP

16 14 10
1 2 3

8
4

7
5

9
6

3
7

2
8

4
9

1
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


16 14 8 2 4 1 7 9 10 3

Ejemplo Min Heap


1 2 8 12 14 11 7 9 3 10

Manteniendo la max-heap-property
Algoritmo MAX-HEAPIFY Este algoritmo sirve para mantener la max-heapproperty Recibe como parmetros 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
4 16 14 2
HEAP 4 2 1

10 7 9

8
4
1

1
16 10
2 3

10

14 7
4 5

9
6

3
7

2
8

8
9

1
10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l= r= largest =
4 1

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) } }

16 2

10 3

14 4

2 HEAP

8
4

1
16 10

10 14 7 9 3 2 8 1

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l=2 r= largest =


4 1

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) } }

16 2

10 3

14 4

2 HEAP

8
4

1
16 10

10 14 7 9 3 2 8 1

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l=2 r=3 largest =


4 1

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) } }

16 2

10 3

14 4

2 HEAP

8
4

1
16 10

10 14 7 9 3 2 8 1

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l=2 r=3 largest =


4 1

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) } }

16 2

10 3

14 4

2 HEAP

8
4

1
16 10

10 14 7 9 3 2 8 1

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l=2 r=3 largest = 2


4 1

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) } }

16 2

10 3

14 4

2 HEAP

8
4

1
16 10

10 14 7 9 3 2 8 1

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l=2 r=3 largest = 2


4 1

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) } }

16 2

10 3

14 4

2 HEAP

8
4

1
16 10

10 14 7 9 3 2 8 1

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l=2 r=3 largest = 2


4 1

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) } }

16 2

10 3

14 4

2 HEAP

8
4

1
16 10

10 14 7 9 3 2 8 1

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,1)

i=1 l=2 r=3 largest = 2


16 1

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) } }

10 3

14 4

8
4

1
10

10 14 7 9 3 2 8 1

HEAP 16

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,2)

i=2 l=2 r=3 largest = 2


16 1

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) } }

10 3

14 4

8
4

1
10

10 14 7 9 3 2 8 1

HEAP 16

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,2)

i=2 l=4 r=5 largest = 2


16 1

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) } }

10 3

14 4

8
4

1
10

10 14 7 9 3 2 8 1

HEAP 16

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,2)

i=2 l=4 r=5 largest = 2


16 1

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) } }

10 3

14 4

8
4

1
10

10 14 7 9 3 2 8 1

HEAP 16

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,2)

i=2 l=4 r=5 largest = 4


16 1

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) } }

10 3

14 4

8
4

1
10

10 14 7 9 3 2 8 1

HEAP 16

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,2)

i=2 l=4 r=5 largest = 4


16 1

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) } }

10 3

14 4

8
4

1
10

10 14 7 9 3 2 8 1

HEAP 16

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,2)

i=2 l=4 r=5 largest = 4


16 1

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) } }

10 3

14 4

8
4

1
10

10 14 7 9 3 2 8 1

HEAP 16

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,2)

i=2 l=4 r=5 largest = 4


16 1

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) } }

14 2

10 3

10 4 7 9 3 2 8 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,4)

i=4 l=4 r=5 largest = 4


16 1

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) } }

14 2

10 3

10 4 7 9 3 2 8 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,4)

i=4 l=8 r=9 largest = 4


16 1

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) } }

14 2

10 3

10 4 7 9 3 2 8 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,4)

i=4 l=8 r=9 largest = 4


16 1

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) } }

14 2

10 3

10 4 7 9 3 2 8 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,4)

i=4 l=8 r=9 largest = 4


16 1

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) } }

14 2

10 3

10 4 7 9 3 2 8 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,4)

i=4 l=8 r=9 largest = 9


16 1

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) } }

14 2

10 3

10 4 7 9 3 2 8 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,4)

i=4 l=8 r=9 largest = 9


16 1

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) } }

14 2

10 3

10 4 7 9 3 2 8 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,4)

i=4 l=8 r=9 largest = 9


16 1

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) } }

14 2

10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,9)

i=9 l=8 r=9 largest = 9


16 1

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) } }

14 2

10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,9)

i=9 l = 18 r = 19 largest = 9
16 1

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) } }

14 2

10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,9)

i=9 l = 18 r = 19 largest = 9
16 1

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) } }

14 2

10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,9)

i=9 l = 18 r = 19 largest = 9
16 1

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) } }

14 2

10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,9)

i=9 l = 18 r = 19 largest = 9
16 1

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) } }

14 2

10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

MAX-HEAPIFY(A,i) { l = LEFT(i) r = RIGHT(i)

MAX-HEAPIFY(A,9)

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

16 1 14 2 10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

16 1 14 2 10 3

10 8 7 9 3 2 4 1

HEAP 16 14 10

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] for } } = length[A] downto 1 { i = length[A]/2 MAX-HEAPIFY(A,i)

Ejemplo
4 1 2 14
HEAP 4 2 1

10/2 = 5

3 16 9

10

8
4
1

7
1
2

10

3
3

2
4

16 9
5 6

10 14 8
7 8 9

7
10

Ejemplo
4 1 2 14
HEAP 4 2 1

MAX-HEAPIFY(A,5)

3 16 9

10

8
4
1

7
1
2

10

3
3

2
4

16 9
5 6

10 14 8
7 8 9

7
10

Ejemplo
4 1 2 14
HEAP 4 2 1

MAX-HEAPIFY(A,4)

3 16 9

10

8
4
1

7
1
2

10

3
3

2
4

16 9
5 6

10 14 8
7 8 9

7
10

Ejemplo
4 1 14 2
HEAP 4 2 1

MAX-HEAPIFY(A,4)

3 16 9

10

8
4
1

7
1
2

10

3
3

14 16 9
4 5 6

10 2
7 8

8
9

7
10

Ejemplo
4 1 14 2
HEAP 4 2 1

MAX-HEAPIFY(A,3)

3 16 9

10

8
4
1

7
1
2

10

3
3

14 16 9
4 5 6

10 2
7 8

8
9

7
10

Ejemplo
4 1 14 2
HEAP 4 2 1

MAX-HEAPIFY(A,3)

10 16 9

8
4
1

7
1
2

10

10
3

14 16 9
4 5 6

3
7

2
8

8
9

7
10

Ejemplo
4 1 14 2
HEAP 4 2 1

MAX-HEAPIFY(A,2)

10 16 9

8
4
1

7
1
2

10

10
3

14 16 9
4 5 6

3
7

2
8

8
9

7
10

Ejemplo
4 16 14 2
HEAP 4 2 1

MAX-HEAPIFY(A,2)

10 7 9

8
4
1

1
16 10
2 3

10

14
4

7
5

9
6

3
7

2
8

8
9

1
10

Ejemplo
4 16 14 2
HEAP 4 2 1

MAX-HEAPIFY(A,1)

10 7 9

8
4
1

1
16 10
2 3

10

14
4

7
5

9
6

3
7

2
8

8
9

1
10

Ejemplo
16 14 8 2
HEAP 4 2 1

10 7 9

10

16 14 10
1 2 3

8
4

7
5

9
6

3
7

2
8

4
9

1
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 tendramos que usar MIN-HEAPIFY y BUILDMIN-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
4 1 2 14
HEAP 4 2 1

3 16 9

10

8
4
1

7
1
2

10

3
3

2
4

16 9
5 6

10 14 8
7 8 9

7
10

Ejemplo
4 1 2 14
HEAP 4 2 1

BUILD-MAX-HEAP(A)

3 16 9

10

8
4
1

7
1
2

10

3
3

2
4

16 9
5 6

10 14 8
7 8 9

7
10

Ejemplo
16 14 8 2
HEAP 4 2 1

BUILD-MAX-HEAP(A)

10 7 9

10

16 14 10
1 2 3

8
4

7
5

9
6

3
7

2
8

4
9

1
10

heapsize

Ejemplo
1 14 8 2
HEAP 4 2 1

A[1] A[10]

10 7 9

4
1
1

16
14 10
2 3

10

8
4

7
5

9
6

3
7

2
8

4
9

16
10

Ejemplo
1 14 8 2
HEAP 4 2 1

Heapsize[A] - 1

10 7 9

4
1
1

16
14 10
2 3

10

8
4

7
5

9
6

3
7

2
8

4
9

16
10

heapsize

Ejemplo
14 8 4 2
HEAP 4 2 1

MAX-HEAPiFY(A,1)

10 7 9

1
14
1

16
8
2

10

10
3

4
4

7
5

9
6

3
7

2
8

1
9

16
10

Ejemplo
1 8 4 2
HEAP 4 2 1

A[1] A[9]

10 7 9

14
1 8

16
10

10

14 16

Ejemplo
1 8 4 2
HEAP 4 2 1

Heapsize[A] - 1

10 7 9

14
1 8

16
10

10

14 16

heapsize

Ejemplo
10 8 4 2
HEAP 4 2 1

MAX-HEAPiFY(A,1)

9 7 1

14 16
10 8 9

10

14 16

Ejemplo
9 8 4 10
HEAP 4 2 1

3 7 1

14 16
9 8 3

10

10 14 16

Ejemplo
8 7 4 10
HEAP 4 2 1

3 2 1

14 16
8 7 3

10

10 14 16

Ejemplo
7 4 1 10
HEAP 4 2 1

3 2 8

14 16
7 4 3

10

10 14 16

Ejemplo
4 2 1 10
HEAP 4 2 1

3 7 8

14 16
4 2 3

10

10 14 16

Ejemplo
3 2 4 10
HEAP 4 2 1

1 7 8

14 16
3 2 1

10

10 14 16

Ejemplo
2 1 4 10
HEAP 4 2 1

3 7 8

14 16
2 1 3

10

10 14 16

Ejemplo
1 2 4 10
HEAP 4 2 1

3 7 8

14 16
1 2 3

10

10 14 16

Ejemplo
1 2 4 10
HEAP 4 2 1

3 7 8

14 16
1 2 3

10

10 14 16

Ejemplo
1 2 4 10
HEAP 4 2 1

3 7 8

14 16
1 2 3

10

10 14 16

Вам также может понравиться