Кажется, что очередь приоритетов - это просто куча с обычными операциями очереди, такими как insert, delete, top и т.д. Является ли это правильным способом интерпретации очереди приоритетов? Я знаю, что вы можете создавать очереди приоритетов по-разному, но если бы я должен был создать очередь приоритетов из кучи, необходимо создать класс очереди приоритетов и дать инструкции для построения кучи и операций очереди или нет необходимости строить класс?
Я имею в виду, если у меня есть функция для создания кучи и функций для выполнения операций, таких как insert, delete, мне нужно поместить все эти функции в класс или я могу просто использовать инструкции, вызвав их в main.
Я предполагаю, что мой вопрос заключается в том, эквивалентен ли набор функций эквивалентным хранению их в каком-то классе и использованию их через класс или просто используя сами функции.
То, что у меня есть, - это все методы для реализации очереди приоритетов. Достаточно ли это назвать его реализацией или мне нужно поместить его в назначенный класс очереди приоритетов?
#ifndef MAX_PRIORITYQ_H
#define MAX_PRIORITYQ_H
#include <iostream>
#include <deque>
#include "print.h"
#include "random.h"
int parent(int i)
{
return (i - 1) / 2;
}
int left(int i)
{
if(i == 0)
return 1;
else
return 2*i;
}
int right(int i)
{
if(i == 0)
return 2;
else
return 2*i + 1;
}
void max_heapify(std::deque<int> &A, int i, int heapsize)
{
int largest;
int l = left(i);
int r = right(i);
if(l <= heapsize && A[l] > A[i])
largest = l;
else
largest = i;
if(r <= heapsize && A[r] > A[largest])
largest = r;
if(largest != i) {
exchange(A, i, largest);
max_heapify(A, largest, heapsize);
//int j = max_heapify(A, largest, heapsize);
//return j;
}
//return i;
}
void build_max_heap(std::deque<int> &A)
{
int heapsize = A.size() - 1;
for(int i = (A.size() - 1) / 2; i >= 0; i--)
max_heapify(A, i, heapsize);
}
int heap_maximum(std::deque<int> &A)
{
return A[0];
}
int heap_extract_max(std::deque<int> &A, int heapsize)
{
if(heapsize < 0)
throw std::out_of_range("heap underflow");
int max = A.front();
//std::cout << "heapsize : " << heapsize << std::endl;
A[0] = A[--heapsize];
A.pop_back();
max_heapify(A, 0, heapsize);
//int i = max_heapify(A, 0, heapsize);
//A.erase(A.begin() + i);
return max;
}
void heap_increase_key(std::deque<int> &A, int i, int key)
{
if(key < A[i])
std::cerr << "New key is smaller than current key" << std::endl;
else {
A[i] = key;
while(i > 1 && A[parent(i)] < A[i]) {
exchange(A, i, parent(i));
i = parent(i);
}
}
}
void max_heap_insert(std::deque<int> &A, int key)
{
int heapsize = A.size();
A[heapsize] = std::numeric_limits<int>::min();
heap_increase_key(A, heapsize, key);
}