Dijkstra 最短路径算法性能 std::p riority_queue VS std::set.

我想了解这些容器在时间复杂度方面的主要区别。 我已经尝试了 3 种 Dijkstra 算法的实现，如下所述：

1-使用简单数组作为队列

2- 带 STL priority_queue

3- 带 STL 设置

我测试过的图非常大，它包含超过 150000 个顶点，定向且边缘的所有权重都是正数。

我得到的结果如下：

1 - 使用数组，算法非常慢 ->这是预期的

2 - 使用 STL priority_queue算法的运行速度比数组快得多 - 这也是预期的>

3 - 使用 STL 设置算法运行速度非常快，我说的是比priority_queue快 100 倍的夫妇 ->我没想到会看到如此巨大的性能......

知道 std：:p riority_queue 和 std：：set 是存储元素的数据容器，并且两者具有基本相同的插入复杂度 O(log n)，我不明白它们之间的这种巨大的性能差异。 你对此有什么解释吗？

感谢您的帮助，

编辑：这是我实现的摘要：

使用 std：：set：

unsigned int Graphe::dijkstra(size_t p_source, size_t p_destination) const {
....

set<pair<int, size_t>> set_vertices;

vector<unsigned int> distance(listAdj.size(),
numeric_limits<unsigned int>::max());

vector < size_t
> predecessor(listAdj.size(),
numeric_limits < size_t > ::max());

distance[p_source] = 0;
set_vertices.insert( { 0, p_source });

while (!set_vertices.empty()) {
unsigned int u = set_vertices.begin()->second;

if (u == p_destination) {
break;
}
set_vertices.erase( { distance[u],
u });

for (auto itr = listAdj[u].begin();
itr != listAdj[u].end(); ++itr) {

int v = itr->destination;
int weigth = itr->weigth;

if (distance[v]
> distance[u] + weigth) {

if (distance[v]
!= numeric_limits<unsigned int>::max()) {
set_vertices.erase(
set_vertices.find(
make_pair(distance[v],
v)));
}
distance[v] = distance[u] + weigth;
set_vertices.insert( { distance[v],
v });
predecessor[v] = u;
}
}
}
....
return distance[p_destination];}

并带有priority_queue：

unsigned int Graphe::dijkstra(size_t p_source, size_t p_destination) const {
...
typedef pair<size_t, int> newpair;
priority_queue<newpair, vector<newpair>, greater<newpair> > PQ;
vector<unsigned int> distance(listAdj.size(),
numeric_limits<unsigned int>::max());

vector < size_t
> predecessor(listAdj.size(),
numeric_limits < size_t > ::max());

distance[p_source] = 0;
PQ.push(make_pair(p_source, 0));
while (!PQ.empty()) {

unsigned int u = PQ.top().first;

if (u == p_destination) {
break;
}
PQ.pop();

for (auto itr = listAdj[u].begin();
itr != listAdj[u].end(); ++itr) {

int v = itr->destination;
int weigth = itr->weigth;

if (distance[v]
> distance[u] + weigth) {
distance[v] = distance[u] + weigth;
PQ.push(
make_pair(v, distance[v]));
predecessor[v] = u;
}
}
}
...
return distance[p_destination];}