C ++-Kruskal算法STL

Question

Based on video I wrote Kruskal's algorithm. But I have "little" problem - instead of finding lowest weights it finds me highest. This may sound funny, but I can't find where I made mistake.

collection::collection(int vert){ coll = new SNode[vert]; }
collection::~collection(){}
void collection::Create(int vert)
{
    coll[vert].up = vert;
    coll[vert].rank = 0;
}
int collection::Find(int vert)
{
    /*if (coll[vert].up != vert) coll[vert].up = Find(coll[vert].up);
    return coll[vert].up;*/
    if (coll[vert].up == vert) return coll[vert].up;
    else Find(coll[vert].up);
}
void collection::Union(graf::Edges e)
{
    int home, dest;
    home = Find(e.v1);
    dest = Find(e.v2);
    if (home != dest){
        if (coll[home].rank > coll[dest].rank){ coll[dest].up = home; }
        else if (coll[home].rank < coll[dest].rank){ coll[home].up = dest; }
        else{
            coll[home].up = dest;             
            //if (coll[home].rank == coll[dest].rank) 
                coll[dest].rank++;
        }
    }
}

And main algorithm. Weights are kept in two dimensional matrix called 'weightmat'. Vertex is quantity of vertices, Edges is struct with variables v1,v2,weight. Using this struct I create array of edges. :

collection newcollection(vertex);

        struct CompareMat{
            bool operator()(Edges &node1, Edges &node2){
                if (node1.weight < node2.weight) return true;
                else return false;
            }
        };

        priority_queue<Edges, vector<Edges>, CompareMat> EdgesQueue;
        Edges temp;
        Edges* edges = new Edges[edge];
        Edges* MSTTree = new Edges[vertex-1];

        for (int i = 0; i < vertex; i++){
            for (int j = 0; j < vertex; j++)
            {
                if (nbhmat[i][j] != 0){
                    edges[i].v1 = i;
                    edges[i].v2 = j;
                    edges[i].weight = weightmat[i][j];
                }
            }
            EdgesQueue.push(edges[i]);
        }

        for (int i = 0; i < vertex; i++){
            newcollection.Create(i);
        }

        for (int i = 1; i < vertex; i++)          
        {
            do
            {
                temp = EdgesQueue.top();             
                EdgesQueue.pop();                    
            } while (newcollection.Find(temp.v1) == newcollection.Find(temp.v2));
            MSTTree[i - 1] = temp;
            newcollection.Union(temp);
        }

        cout << endl << endl << "Kruskal's algorithm for matrix:" << endl;
        for (int i = 0; i < vertex - 1; i++){
            cout << MSTTree[i].v1 << " " << MSTTree[i].v2 << " weight " << MSTTree[i].weight << endl;
        }

Answer 1

priority_queue has the biggest element on its top (yes, with the comparator class being equivalent to less ), but you need the smallest edges first. You need to invert your CompareMat::operator() comparison.

Two more notes.

Firstly, in CompareMat::operator() you can return comparison result directly:

//return node1.weight < node2.weight; // your version
return node1.weight > node2.weight;  // correct version

Secondly, why do you need a priority queue? A simple sort will suffice, because you do not seem to change your edges.