Запись очереди с приоритетной структурой кучи в переполнении стека

В вашем исходном коде индекс, используемый внутри Dequeue () для доступа к вектору, похоже, инициализирован неправильно. Давайте предположим, что вы добавили две записи в свой список. В этом случае значение P.m_priority внутри main () равно 2. Теперь вы впервые вызываете printJobs (). printJobs () вызывает pq.Dequeue (p.m_priority, p.m_name), поэтому Dequeue () получает p.m_priority в качестве параметра вещь. Имейте в виду, что вещь имеет значение 2.

m_Items.m_elements[0] = m_Items.m_elements.back();
std::cout << "Now printing Job#" << m_Items.m_elements[item - 1] << " " << lName.c_str() << std::endl;
m_Items.m_elements.pop_back();

Вы получаете доступ к своему std :: vector, используя индекс вещь — 1. Это работает впервые, так как в вашем списке есть два элемента. В этом вызове в вашем списке также выполняется pop_back (), который уменьшает его размер на единицу. При следующем вызове printJobs () данный параметр вещь не будет изменен, он по-прежнему имеет значение 2. Когда вы обращаетесь к своему списку элементов, больше нет индекса 1 и индекс вне диапазона исключение будет брошено.

Не было фиксированных приоритетов, назначенных трем типам записей в исходной версии, поэтому я добавил их (см. AddJobs ()).

Таким образом, возможное решение для сохранения имени человека может выглядеть так:

struct Person
{
int m_priority;
std::string m_name;

Person()
{
m_priority = 0;
m_name = " ";
}
};

struct Heap
{
std::vector<Person> m_elements;

void ReHeapDown(int, int);
void ReHeapUp(int, int);
void Swap(Person& a, Person& b);
};

void Heap::ReHeapDown(int index, int bottom)
{
int maxChild, rightChild, leftChild;

leftChild = index * 2 + 1;
rightChild = index * 2 + 2;

if (leftChild <= bottom)
{
if (leftChild == bottom)
maxChild = leftChild;
else
{
if (m_elements[leftChild].m_priority <= m_elements[rightChild].m_priority)
maxChild = rightChild;
else
maxChild = leftChild;
}
if (m_elements[index].m_priority < m_elements[maxChild].m_priority)
{
Swap(m_elements[index], m_elements[maxChild]);
ReHeapDown(maxChild, bottom);
}
}
}

void Heap::ReHeapUp(int index, int bottom)
{
int  parent;

if (bottom  > index)
{
parent = (bottom - 1) / 2;
if (m_elements[parent].m_priority  <  m_elements[bottom].m_priority)
{
Swap(m_elements[parent], m_elements[bottom]);
ReHeapUp(index, parent);
}
}
}

void Heap::Swap(Person& a, Person& b)
{
Person temp;
temp = a;
a = b;
b = temp;
}

#include <iostream>

class PQTYPE
{

private:
Heap m_Items;

public:
bool isEmpty() const;
void Enqueue(Person);
void Dequeue();
void printElements();
};

bool PQTYPE::isEmpty() const
{
return m_Items.m_elements.empty();
}

void PQTYPE::Enqueue(Person newItem)
{

if (!newItem.m_name.compare("Student"))
{
m_Items.m_elements.push_back(newItem);
m_Items.ReHeapUp(0, m_Items.m_elements.size() - 1);
}
else if (!newItem.m_name.compare("TA"))
{
m_Items.m_elements.push_back(newItem);
m_Items.ReHeapUp(0, m_Items.m_elements.size() - 1);
}
else if (!newItem.m_name.compare("Instructor"))
{
m_Items.m_elements.push_back(newItem);
m_Items.ReHeapUp(0, m_Items.m_elements.size() - 1);
}
}

void PQTYPE::Dequeue()
{
if (isEmpty())
std::cout << "No jobs to print\n";
else
{
Person front = m_Items.m_elements.front();
std::cout << "Now printing Job#" << front.m_priority << " " << front.m_name.c_str() << std::endl;
m_Items.m_elements.erase(m_Items.m_elements.begin());
m_Items.ReHeapDown(0, m_Items.m_elements.size() - 1);
}
}void PQTYPE::printElements()
{
if (isEmpty())
std::cout << "No jobs to print\n";
else
{
for (int i = 0; i < m_Items.m_elements.size(); i++)
{
std::cout << "Job#" << m_Items.m_elements[i].m_priority << " " << m_Items.m_elements[i].m_name.c_str() << std::endl;
}
}
}

int showMenu();
void addJobs(PQTYPE&, Person&);
void printJobs(PQTYPE&, Person&);
void viewJobs(PQTYPE&);

int showMenu()
{
int choice;
std::cout << " 1.)Add Job\n";
std::cout << " 2.)Print Job\n";
std::cout << " 3.)View Jobs\n";
std::cout << " 4.)Exit\n";
std::cout << " Enter Choice: ";
std::cin >> choice;

return choice;
}

void addJobs(PQTYPE& pq, Person& per)
{
char jobChoice;

std::cout << "Who is the job for ( Instructor(i or I), TA(t or T), Student(s or S) :";
std::cin >> jobChoice;

if (jobChoice == 'S' || jobChoice == 's')
{
per.m_priority = 0;
per.m_name = "Student";
pq.Enqueue(per);
}
else if (jobChoice == 'T' || jobChoice == 't')
{
per.m_priority = 1;
per.m_name = "TA";
pq.Enqueue(per);
}
if (jobChoice == 'I' || jobChoice == 'i')
{
per.m_priority = 2;
per.m_name = "Instructor";
pq.Enqueue(per);
}
}

void printJobs(PQTYPE& pq)
{
pq.Dequeue();
}

void viewJobs(PQTYPE& pq)
{
pq.printElements();
}

int main()
int option;
Person p;
PQTYPE pq;

do
{
option = showMenu();

switch (option)
{
case 1: addJobs(pq, p);
break;
case 2: printJobs(pq);
break;
case 3: viewJobs(pq);
break;
case 4:
break;
default: std::cout << "Wrong input\n";
break;
}

} while (option != 4);

return 0
}

Вы уверены, что методы ReHeapUp и ReHeapDown соответствуют вашим требованиям? И не должно ли быть различие между номером работы и приоритетом?