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