我正在尝试使用此代码创建优先级队列，但找不到问题所在。有人告诉我我哪里错了。
<?php
class PriorityQueue implements Iterator , Countable
{
public function __construct() {
$flags = self::EXTR_DATA;
$items = array();
}
function compare ( mixed $priority1 , mixed $priority2 ){}
function count (){
return count($this->items);
}
function current (){
switch ($this->flags) {
case self::EXTR_BOTH:
$ret = array();
$ret['Patient'] = current($this->items);
$ret['Priority'] = $this->key();
break;
case self::EXTR_DATA:
$ret = current($this->items);
break;
case self::EXTR_PRIORITY:
$ret = $this->key();
break;
};
return $ret;
}
function extract (){
$ret = $this->current();
$this->next();
return $ret;
}
function …众所周知，插入优先级队列的元素具有确定其优先级的值。例如，如果我有五个A,B,C,D,E具有优先级的元素（我们称之为优先级值priorityI）：
A = 10, B = 5, C = 1, D = 3, E = 2。但是我如何编写一个可以定义两个优先级值的优先级队列，我的意思是：如果两个元素具有相同的值priorityI，则值priorityII决定应首先采用哪个元素，例如：
element A has priorityI = 3, and prioriotyII = 5
element B has priorityI = 3, and prioriotyII = 1
那么第一个元素 B 将首先从队列中取出。
我正在尝试创建一个由 int, char 对组成的优先级队列，它为我提供了具有更大 int 的对，但我的代码无法正常工作。我究竟做错了什么？
这是我的比较器类：
class Compare
{
public:
bool operator() (pair<int, char>a, pair<int, char>b)
{
return a.first > b.first;
}
};
这是我的优先级队列：
priority_queue<pair<int, char>, vector<pair<int, char>>, Compare> party;
但是如果我执行代码：
party.push(make_pair(2, 'A'));
party.push(make_pair(3, 'B'));
cout<<party.top().first;
它返回 2，而不是 3。如何修复优先级队列的实现？
我正在尝试使用标准库优先级队列来对自定义类的对象进行排序Foo。但是，比较元素取决于它们在 unordered_map 中映射到的值map。
我正在尝试构建这样的东西：
std::unordered_map<Foo,double> map;
struct Compare {
bool operator()(const Foo& a, const Foo& b) {
return map[a]<map[b];
}
}
std::priority_queue<Foo,std::vector<Foo>,Compare> queue;
然而，看起来我不允许引用封闭函数的局部变量。
实现这一目标的标准方法是什么？
由于我无法在 flutter 中使用优先级队列，因此优先级队列集合在 dart 中可用吗？
如果是这样，请写一个如何使用它的片段。我无法找到有关如何在颤振中使用优先级队列的任何方便的解释。
有更好的方法来转换PriorityQueue<int[]> pq吗int[pq.size()][pq.peek().length]？
pq.toArray()给出一个Object数组，但我不太确定如何将其转换为数组int。
我尝试过的一种方法是：
PriorityQueue<int[]> pq = new PriorityQueue<int[]>();
int[] fin = new int[pq.size()];
for(int i=0;i<pq.size();i++) {
fin[i] = pq.remove();
}
但我正在寻找更好的时间优化解决方案。
我注意到std::priority_queue以排序的方式存储元素。显然，以排序方式存储元素将是一个糟糕的设计选择，因为push和的时间复杂度pop将达到O(n)。但事实证明，它std::priority_queue神奇地在线性时间内对元素进行了排序。
这是我用于测试的代码。
#include <iostream>
#include <queue>
#include <algorithm>
#include <vector>
#include <chrono>
#include <random>
#include <climits>
#include <fstream>
#include <ios>
int main() {
int size = 10'000'000;
std::random_device rd;
std::mt19937 mt{rd()};
std::uniform_int_distribution<int> uid{1, INT32_MAX};
std::vector<int> vs;
for (int i = 0; i < size; ++i) {
vs.push_back(uid(mt));
}
// Measures time taken by make_heap
std::vector<int> vs1{vs};
auto start = std::chrono::system_clock::now();
std::make_heap(vs1.begin(), vs1.end());
auto end = std::chrono::system_clock::now();
std::chrono::duration<double> diff = end …如何清除priority_queue使用用户定义的比较？
从std::priority_queue文档priority_queue中，我减少了我需要的情况的使用（=带有用户定义比较的队列）
>> cat test.cpp \n#include <functional>\n#include <queue>\n#include <vector>\n#include <iostream>\n#include <utility>\n\nauto queue_cmp = [](std::pair<int, double> const& lhs,\n std::pair<int, double> const& rhs) {\n return lhs.second > rhs.second; // Custom order.\n};\ntypedef std::priority_queue<std::pair<int, double>,\n std::vector<std::pair<int, double>>,\n decltype(queue_cmp)> custom_queue;\n\ntemplate<typename T>\nvoid print_queue(T q) { // NB: pass by value so the print uses a copy\n int s = 0;\n while(!q.empty()) {\n std::pair<int, double> elem = q.top();\n std::cout << s << ": " << elem.first << ", " …我是C++中的OOP新手,我不确定这是否可行,但我想在C++ std优先级队列中有多个类类型.
我设置了这些类,以便它们都从一个基类继承,然后使用基类来创建所有函数,我只是不知道如何让所有东西都调用子类函数.在我调用foo()函数时,它调用父函数而不是子函数
有没有办法在没有明确知道它是什么类型的情况下退回？我将有几个不同的子类,它们将执行不同的操作,而不仅仅是显示的单个类.
代码的输出目前是Parent我猜对了Child.
我有一种感觉我正在做virtual关键字的错误,应该foo()是一个纯粹的虚函数？
Parent.h
#pragma once
class Parent{
public:
virtual ~Parent(){};
virtual std::string foo() const { return "Parent"; }
};
Child.h
#pragma once
#include <iostream>
#include "Parent.h"
class Child: public Parent{
public:
Child();
~Child();
std::string foo() const;
};
Child.cpp
#include <iostream>
#include "Parent.h"
#include "Child.h"
Child::Child(){}
Child::~Child(){}
std::string Child::foo() const{ return "Child"; }
main.cpp中
#include <iostream>
#include <queue>
#include "Parent.h"
#include "Child.h"
using namespace std;
//Fake compare …我正在尝试使用静态数组实现基于二进制堆的优先级队列(我稍后将使用链表,只是想先用数组进行测试).
typedef struct n
{
int x;
int y;
int size;
double value;
} node;
node arr[100];
int total = 1;
void insertElement(int x, int y, int size, double value)
{
node n;
n.x = x;
n.y = y;
n.size = size;
n.value = value;
arr[total] = n;
if (total > 1)
insertArrange(total);
total += 1;
}
现在在删除功能中,我将返回最顶层节点并将其删除,然后重新排列整个堆.问题是我无法释放任何记忆.假设我使用
free(&arr[1]);
我得到指针被释放没有分配错误.这是正确的实施方式吗？如何解决内存问题？
我正在使用Xcode和Apple LLVM 4.2编译器.这整个事情最终将被放入Objective-C中的一个更大的项目中,但是现在我不想使用NSMutableArray.我想要一个简单的C解决方案.