1
已取得进展，但仍无法揣摩出我的无限循环是优先级队列......C++二进制堆
头文件：
#include <string>
class priority_queue_overflow{}; //if insert tries to exceed the size of A then throw priority_queue_overflow()
class priority_queue_underflow{}; //if extract_min tries is called on an empty heap then throw priority_queue_overflow()
class priority_queue {
private:
class pair {
public:
std::string object;
double key;
};
pair* A; //the array used to store the heap
int heapsize; //the current heap size
int size; //the current size of the array: does not change
void heapify(int k); //as described in Cormen et al
public:
priority_queue(int n); //don't forget to allocate the array of size n+1 as we don't use slot zero
~priority_queue(); //delete the array
bool empty(); //true/false depending upon whether the heap is empty
void insert(std::string s, double priority); //add s to the heap with the given priority as its key
std::string extract_min(); //remove the string of lowest key and return that string
operator std::string();
};
CPP文件：
/**
* implementing the priority queue as a binary heap
*
*/
#include <iostream>
#include <istream>
#include <ostream>
#include <sstream>
#include <map>
#include <algorithm>
#include "binary_heap.hpp"
/***********************
*** inline functions
***********************/
inline int left(int i) { return 2*1; } // (i << 1)
inline int right(int i) { return 2*i+1; } // (i << 1 | 1)
inline int parent(int i) { return i/2; } // (i >> 1)
/*********************
*** constructor
*********************/
priority_queue::priority_queue(int n) //don't forget to allocate the array of size n+1 as we don't use slot zero
:heapsize(0), size(n)
{
A = new pair[n+1];
}
/*********************
*** destructor
*********************/
priority_queue::~priority_queue() //delete the array
{
delete[] A; // iterrate through delete each elem
}
/*******************************************
*** heapify * finds max of three things
*******************************************/
void priority_queue::heapify(int k)
{
std::cout<<"HERE HEAP"<<'\n';
pair smallest = A[k];
int pos = k;
//only treat child as object if it's inside heap
if (left(k) <= heapsize and A[left(k)].key < A[pos].key) {
// update variables
smallest = A[left(k)];
pos = left(k);
}
// identical for right
if (right(k) <= heapsize and A[right(k)].key < A[pos].key) {
// update variables
smallest = A[right(k)];
pos = right(k);
}
// after both if's exectued: smallest and pos contain smallest key
// only need to do something if pos is !=i
std::cout<< pos <<" == "<< k<<'\n';
if (pos != k) {
// swap items
std::swap(A[k], A[pos]);
// go recursive
heapify(pos);
}
}
/****************
*** empty
****************/
bool priority_queue::empty()
{
return (heapsize == 0);
}
/****************
*** insert
****************/
void priority_queue::insert(std::string s, double priority) //add s to the heap with the given priority as its key
{
if (heapsize == size) {
throw priority_queue_overflow();
}
++heapsize;
A[heapsize].object = s;
A[heapsize].key = priority;
int i(heapsize);
while (i > 1 and A[parent(i)].key > A[i].key) {
std::swap(A[parent(i)], A[i]);
i = parent(i);
}
}
/*******************
*** extract_min
*******************/
std::string priority_queue::extract_min() //remove the string of lowest key and return that string
{
if (heapsize == 0) {
throw priority_queue_underflow();
}
std::string ans = A[1].object;
A[1] = A[heapsize];
--heapsize;
heapify(1);
return ans;
}
/**********************************
*** function operator overload
**********************************/
priority_queue::operator std::string()
{
std::stringstream text;
int i(1);
while (i <= size) {
text << A[i].object << std::endl;
++i;
}
return text.str();
}
您的'pair'类没有任何私人成员？ （你也可以用'std :: pair'从''替换它）。但我不确定你在问什么，请你澄清一下？ –
user786653
errr对不起 - 这两个公共成员，对象和键，需要存储在一个数组中，但我不明白如何单独访问每个成员，以及他们需要在构造函数中初始化的地方/方式 – Bill
您的问题是在'priority_queue :: insert'中获得'A [heapsize] = priority'才能正常工作？你应该编辑你的问题，并强调你在哪里遇到问题。 （顺便说一句：这应该是'A [heapsize] .object = s; A [heapsize] .priority = priority;'和'++ heapsize'应该在之后*我认为*） – user786653