Kolejka prioryetowa nie łapie priorytetu

Witam, to znowu ja. Napisałem sobie testowo kolejkę priorytetową o wielkości 10 elementów wypełnioną - pierwszy element 0 a reszta 999. Następnie chciałem zobaczyć jak kolejka będzie mi sie sortowała więc zmieniłem wartość elementów 1 i 5 tak jak poniżej w kodzie, tyle że kolejka niepoprawnie sortuje. Powinno być 0, 3, 10, 999, 999.... a jest 0, 3, 999, 10, 999, 999... tak jakby 999 < 10 ?!

class Graph_node
{
    public:
    
    long int ref;
    double lat;
    double lon;
    
    double distance_from_source;
};
class XComparator {
    public:
 
    bool operator()(const Graph_node * node1, const Graph_node * node2);
};

bool XComparator::operator()(const Graph_node * node1, const Graph_node * node2) 
{
    return (node1->distance_from_source > node2->distance_from_source);
}

int main() 
{ 
    priority_queue<Graph_node*, vector<Graph_node*>, XComparator> p_queue;
    Graph_node * tab[10];
    for(int i=0; i<10; i++)
    {
	Graph_node * ob;
	ob = new Graph_node;
	ob->ref=i;
	if(i==0) ob->distance_from_source =0;
	else ob->distance_from_source=999;
	p_queue.push(ob);
	tab[ob->ref] = ob;
    }
    
    tab[5]->distance_from_source = 10;
    tab[1]->distance_from_source = 3;
    while(!p_queue.empty())
    {
	Graph_node * a;
	a = p_queue.top();
	cout<<a->distance_from_source<<endl;
	p_queue.pop();
	

    }
    
    return 0;
}

Wie ktoś skąd to dziwne zjawisko?

Zjawisko nie jest dziwne. std::priority_queue ustawia element na odpowiedniej pozycji po jego umieszczeniu w strukturze. Nie bardzo ma skąd się dowiedzieć że dokonałeś zmiany. Powinieneś ustawić wartości przed wstawieniem ich do struktury.

W takim razie jaki sens ma stosowanie tej kolejki np w algorytmie Dijkstry skoro tam wartosci tej kolejki zmieniaja sie w trakcie dzialania programu a olejka zawsze ma wypluwac najmniejszy element?

Item get;
while(true)
  {
   Item x=kolejka.top();
   get=kolejka.push(kolejka.pop());
   if(x==get) break;
  }

Jeszcze mam pytanko z innej beczki. To jest pseudokod algorytmu Dijkstry (źr. Wikipedia):

Dijkstra(G,w,s):
   dla każdego wierzchołka v w V[G] wykonaj
      d[v] := nieskończoność
      poprzednik[v] := niezdefiniowane
   d[s] := 0
   Q := V
   dopóki Q niepuste wykonaj
      u := Zdejmij_Min(Q)
      dla każdego wierzchołka v – sąsiada u wykonaj
         jeżeli d[v] > d[u] + w(u, v) to
            d[v] := d[u] + w(u, v)
            poprzednik[v] := u

   cout <<"Droga wynosi: "<<d[v];

W skrócie polega on na wyszukiwaniu najkrótszych ścieżek od wierzchołka A do wszystkich pozostałych w grafie. Sąsiadami wierzchołka A nazywamy wierzchołki połączone krawędzią z A. W powyższym pseudokodzie, u - aktualny wierzchołek o najkrótszej drodze a v to jego sąsiad. Tu moje pytanie: skoro v jest sąsiadem u to poprzednikiem v jest u, więc po co to przypisanie poprzednik[v] := u ? Soro to wychodzi na to że przypisujemy u := u?

Poprzednikiem fizycznym v jest u oraz a,b,c, ...
Poprzednikiem v aby uzyskać obecną wartość kosztu jest tylko u.

Mógłbyś to pokazać jak to wygladałoby w implementacji tylko tego pseudokodu? Załóżmy że mamy dane te wszystkie kolejki itd, bo dla mnie nadal przypisując tę wartość nic się nie zmieni...