Министерство образования республики Молдова

Технический Университет Молдовы

Департамент Программной Инженерии и Автоматики

Отчёт
Лабораторная работа №3
Тема: Организация очереди с приоритетом с помощью кучи

Проверила Скороходова Т.

Кишинёв – 2021
 Тема: Организация очереди с приоритетом с помощью кучи
Цель: Изучение основного свойства кучи, ее построение и сортировка. Организация очереди с
приоритетом с помощью кучи.
Задания к лабораторной работе:
1. Привести, используя псевдокоды, алгоритмы основных операций над кучей
- поддержание основного свойства кучи (HEAPIFY);
- построение кучи (BUILD-HEAP);
- сортировка массива (HEAP-SORT);
- взятие наибольшего элемента массива (HEAP-EXTRACT-MAX);
- добавление элемента (HEAP-INSERT);
2. Реализовать алгоритм построения кучи.
3. Реализовать алгоритм сортировки с помощью кучи.
4. Организовать очередь с приоритетами и показать работу процедур:
- HEAP-INSERT (A,key) для кучи А;
- HEAP-EXTRACT-MAX для этой кучи.
№ варианта Массив А Элемент добавления, key
7 21, 35, 56, 41, 24, 88, 6, 11, 57, 15 40

1.

21
35 56

41 24 88 6

11 57 15
2.Псевдокод функций кучи:

HEAP
Parent(i)
return i/2;
Left(i)
return 2*i;
Right(i)
return 2*i+1;

HEAPIFY(A,i)
l <— Left(i)
r <— Right(i)
if (l <= heap.size[A] & A[l]>A[i])
largest <— l
else largest <— i
if (r <= heap.size[A] & A[r]>A[largest])
largest <— r
if ( largest = i )
swap(A[i], A[largest])
HEAPIFY(A,largest)

BUILDHEAP(A)
heap.size[A] <— length[A]
for i <— |_length[A]/2_| down to 1
do HEAPIFY(A,i)

HeapSort(A)
BuildHeap(A)
for i <— length[A] down to 2
do swap(A[1],A[i])
heap.size[A] <— heap.size[A]-1
HEAPIFY(A,1)
 HeapExtractMax(A)
if heap.size[A] < 1then “Очередь пустая”
max= A[1]
A[1] <— A[heap.size[A]]
heap.size[A]
HEAPIFY(A,1)
return max

HeapInsert(A, key)
heap.size[A] <— heap.size[A]+1
i <— heap.size[A]
while i > 1 & A[Parent(i)]
do A[i] <— A[Parent(i)]
i <— Parent(i)
A[i] <— key
3.
Работа алгоритмов.
Buildheap
1 2 3 4 5 6 7 8 9 10
21 35 56 41 24 88 6 11 57 15

21
35 56

41 24 88 6

11 57 15
 1 2 3 4 5 6 7 8 9 10
21 35 56 41 24 88 6 11 57 15

21
35 56

41 24 88 6

11 57 15

1 2 3 4 5 6 7 8 9 10
21 35 56 57 24 88 6 11 41 15

21
35 56

57 24 88 6

11 41 15
 1 2 3 4 5 6 7 8 9 10
21 35 88 57 24 56 6 11 41 15

21
35 88

57 24 56 6

11 41 15

1 2 3 4 5 6 7 8 9 10
21 57 56 41 24 88 6 11 35 15

21
57 88

41 24 56 6

11 35 15
 1 2 3 4 5 6 7 8 9 10
88 57 56 41 24 21 6 11 35 15

88
57 56

41 24 21 6

11 35 15

Heapsort

1 2 3 4 5 6 7 8 9 10
21 35 56 41 24 88 6 11 57 15

21
35 56

41 24 88 6

11 57 15
 1 2 3 4 5 6 7 8 9 10
88 35 56 41 24 21 6 11 57 15

88
35 56

41 24 21 6

11 57 15

1 2 3 4 5 6 7 8 9 10
15 35 56 41 24 21 6 11 57 88

15
35 56

41 24 21 6

11 57
 1 2 3 4 5 6 7 8 9 10
15 35 56 41 24 21 6 11 57 88

15
35 56

41 24 21 6

11

1 2 3 4 5 6 7 8 9 10
56 35 21 41 24 15 6 11 57 88

56
35 21

41 24 15 6

11
1 2 3 4 5 6 7 8 9 10
11 35 21 41 24 15 6 56 57 88

11
35 21

41 24 15 6

1 2 3 4 5 6 7 8 9 10
41 35 21 11 24 15 6 56 57 88

41
35 21

11 24 15 6

1 2 3 4 5 6 7 8 9 10
6 35 21 11 24 15 41 56 57 88

6
35 21

11 24 15
1 2 3 4 5 6 7 8 9 10
35 24 21 11 6 15 41 56 57 88

35
24 21

11 6 15

1 2 3 4 5 6 7 8 9 10
15 24 21 11 6 35 41 56 57 88

15
24 21

11 6

1 2 3 4 5 6 7 8 9 10
24 15 21 11 6 35 41 56 57 88

24
15 21

11 6
1 2 3 4 5 6 7 8 9 10
6 15 21 11 24 35 41 56 57 88

6
15 21

11

1 2 3 4 5 6 7 8 9 10
21 15 6 11 24 35 41 56 57 88

21
15 6

11

1 2 3 4 5 6 7 8 9 10
11 15 6 21 24 35 41 56 57 88

11
15 6

1 2 3 4 5 6 7 8 9 10
15 11 6 21 24 35 41 56 57 88

15
11 6

1 2 3 4 5 6 7 8 9 10
6 11 15 21 24 35 41 56 57 88

6
11

1 2 3 4 5 6 7 8 9 10
6 11 15 21 24 35 41 56 57 88

HeapExtractMax(A)
if heap.size[A] < 1then “Очередь пустая” 10<1 false
max= A[1] max = 88
A[1] <— A[heap.size[A]] A[1] = 15
heap.size[A] heap.size[A] = 9
HEAPIFY(A,1)
return max return 88

15 57 56 41 35 21 6 24 11
4. Сравнение времени работы алгоритмов сортировки кучи с алгоритмами сортировки,
рассмотренныеми в лабораторной работе №2
 Название Лучший Среднее время Худший случай
алгоритма случай
HeapSort O(nlogn) O(nlogn) O(nlogn)
MergeSort O(nlogn) O(nlogn) O(nlogn)
QuickSort O(n) O(nlogn) O(n2)
InsertionSort O(n) O(n2) O(n2)

Вывод:
В данной лабораторной работе была проведена и продемонстрирована работа алгоритмов кучи:
HEAPIFY, EXTRACT-MAX, HEAP-INSERT, HEAP-SORT, BUILD-HEAP. А также было
проведено сравнение работы алгоритма с Insertion-Sort, Merge-Sort и Quick-Sort для худшего,
среднего и лучшего случая. Рассмотрены псевдокоды функций кучи и иллюстрация их работы.