Kruskalov Algoritem

To je psevdokod od kruskalovega algoritma:
function KRUSKAL(P, R)
begin
HITRO_UREDI(P, 0, št_povezav);
R := 0;
koncano = false;
i := 1;
št_sprej_pov := 0;
while not koncano do
begin
if not pogoj 1 then
begin
if P[i] ustreza pogoju 2 then
begin
R := R ∪ {P[i]};
št_sprej_pov := št_sprej_pov + 1;
Združi množici;
end
else if P[i] ustreza pogoju 3 then
begin
R := R ∪ {P[i]};
št_sprej_pov := št_sprej_pov + 1;
Pridruži množici vozlišče p ali q;
end
else if P[i] ustreza pogoju 4 then
begin
R := R ∪ {P[i]};
št_sprej_pov := št_sprej_pov + 1;
Ustvari novo množico {p, q};
end
end
if št_sprej_pov = n-1 then
koncano := true;
else
i := i+1;
end
end
Če mi lahko gdo to pomaga prevesti v c++?

Ena moja rešitev. SIcer je že stara, ampak vseeno

// [maj 2001]
// Opis:   Kruskalov algoritem za iskanje minimalnega vpetega drevesa  
//
#include <iostream>
#include <windows.h>
#include<process.h>
#include<malloc.h>
#include <stdlib.h>
#include <string>
#include <vector>
#include <fstream>

using namespace std;

struct Tocka
{
 int x;
 int y;
 int cena;
 int skupina;
};

#define MAX 1000000

int TabTo[MAX+1];//tabela tock za ugotavljanje MVD
int SteviloTock;//stevilo tock
int Stevilo;//stevilo povezav
int Sprejeta;//stevilo sprejetih povezav
int Cena; //skupna cena

//za struct
Tocka TabPo[MAX+1];//polje povezav (x,y, cena, skupina)

int main()

{
    CString;
//    CString str;
	TVnosDialog Vnos;
	Vnos.DoModal();                     //poizvedba podatka o stevilu tock
	SteviloTock=Vnos.m_stevilo;
    Stevilo=0;                          
	for(int i=0;i&ltSteviloTock-1;i++)    //generiranje matrike
    {
		for(int j=i+1;j<SteviloTock;j++)
		{
			TabPo[Stevilo].x=i;          
			TabPo[Stevilo].y=j;
			TabPo[Stevilo].cena=rand();
            TabPo[Stevilo].skupina=0;
            
            Stevilo++;                  //stevilo vseh povezav
		}
        TabTo[i]=0;                     //inic. matrike
    }
	SteviloVneseno=true;
	str.Format("%d vozlišč s %d povezavami generiranih!",SteviloTock,Stevilo);
 	MessageBox(str,"Obvestilo");
	
}



//###############################################################

//Opis:   Zazene algoritem, pred tem inic. eno od matrik  
//Global: TabTo[]
//Klici: OnRun()
void CAlgoritmiView::OnNajdi() 
{
	for(int i=0;i<Stevilo;i++) TabTo[i]=0;
	OnRun();
	
}


//#####################################################################
//Opis: del algo. quicksort, ki deli mnozice v dve podmnozici
//Vhodi: zacetek: indeks zacetka mnozice
//       konec: indeks konca mnozice
//Izhod: konec: delilni clen
//Global: TabPo[]:matrika cen povezav
//         
int CAlgoritmiView::Deli(int zacetek, int konec)
{
	int prim=zacetek; 
	Tocka Sprim=TabPo[prim];
	Tocka temp;
	
	while(zacetek<=konec)            //dokler se ne krizata
	{                                //iscem st. za zamenjavo
		while(TabPo[zacetek].cena<=Sprim.cena && zacetek<=konec) zacetek++;
		while(TabPo[konec].cena>=Sprim.cena && zacetek<=konec) konec--;
		if(zacetek<=konec)           //zamenjava, ce se nista prekrizana
		{
		temp=TabPo[zacetek];
		TabPo[zacetek]=TabPo[konec];
		TabPo[konec]=temp;
		}
	}
	TabPo[prim]=TabPo[konec];       //zamenjava konca z delilnim
	TabPo[konec]=Sprim;

	return konec;                   //vracanje delilnega
}

    

//#####################################################################

//Opis:   del algo. quicksort, ki deli problem na podprobleme  
//Vhodi: zacetek: indeks zacetka 'pod'mnozice
//       konec: indeks konca 'pod'mnozice
//Klici: Deli(): za poizvedbo delilnega clena
//       HitroUredi(): rekurzivni klic
void CAlgoritmiView::HitroUredi(int zacetek, int konec)
{
  if(zacetek<konec)           //do trivialnosti
  {
   int j=Deli(zacetek,konec); //dobimo delilnega
   HitroUredi(zacetek,j-1);   //uredimo zgornji del
   HitroUredi(j+1,konec);     //uredimo spodnji del
  }
}



//#####################################################################

//Opis:   preveri, ce je quicksort uspesen  
//Global: TabPo[]: matrika cen povezav
bool CAlgoritmiView::PreveriUrejenost()
{
    for(int i=1;i<Stevilo;i++)
        if(TabPo[i-1].cena>TabPo[i].cena) return false;
    return true;
}



//################################ iskanje mini. vpetega drevesa ###############

//Opis:   dejansko poisce minimalno vpeto drevo  
//Global:TabPo[]: tabela cen povezav
//       TabTo[]: tabela tock za skupine
//       SteviloTock: stevilo tock
//       Stevilo: stevilo vseh povezav
void CAlgoritmiView::IsciMVD()
{
    int skupina=1;
    int p,q;
    int j,temp,konec=(SteviloTock*(SteviloTock-1))/2;
    Sprejeta=0;
	Cena=0;
    for(int i=0;i<Stevilo && Sprejeta<=konec;i++)
    {
        p=TabPo[i].x;
        q=TabPo[i].y;
        if(TabTo[p]==0)//prva nikjer
        {
			if(TabTo[q]==0)//druga nikjer, sprejmemo v novo skupino
			{
            TabTo[p]=skupina;
            TabTo[q]=skupina++;
            TabPo[i].skupina=1;
            Sprejeta++;
			}
			else//druga ze, sprejmemo tja
			{
				TabTo[p]=TabTo[q];
				TabPo[i].skupina=1;
				Sprejeta++;
			}
			Cena+=TabPo[i].cena;
        }
		else//prva ze sprejeta
		{
			if(TabTo[q]==0)//druga se ni sprejmemo v skupino prve
			{
				TabTo[q]=TabTo[p];
				TabPo[i].skupina=1;
				Sprejeta++;
				Cena+=TabPo[i].cena;
			}
			else if(TabTo[p]!=TabTo[q])//tudi druga je, zavrnemo
			{
				temp=TabTo[q];
                for(j=0;j<SteviloTock;j++)
                    if(TabTo[j]==temp) TabTo[j]=TabTo[p];
                TabPo[i].skupina=1;
                Sprejeta++;
				Cena+=TabPo[i].cena;
			}
		}
    }
}


//################################ branje datoteke ###############

//Opis:   prebere matirko cen povezav iz datoteke  
//Global:TabPo[]: matirka cen povezav med tockami
//       SteviloTock[]: stevilo tock
//       Stevilo: stevilo vseh povezav
//       SteviloVneseno: da lahko zazenemo algo. za iskanje
void CAlgoritmiView::OnFajl() 
{
    CString str;
    char cena[6];//max 6 cifer
    //char *ime;
    int z;
    int i=0; //vrstica
    int j=1; //stolpec
    char znak;
	
	//filter za datoteke, z neta
	CFileDialog dlg( 
        TRUE,                                       // Open File Dialog 
        _T("mvd"),                                  // Default extension 
        NULL,                                       // No default filename 
        OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,     // OPENFILENAME flags 
        _T("Minimalno vpeto drevo|*.mvd|All Files|*.*||"));  // Filter strings 

	//
	dlg.DoModal();                        //izvem ime datoteke
	str=dlg.GetPathName();

    ifstream vhod(str, ios::in | ios::nocreate); //odprem, ne kreiram

    if(!vhod) //a datoteka obstaja
    {
        str.Format("Datoteka %s ne obstaja!",str);
        MessageBox(str,"Obvestilo");
        return;
    }
    i=1;
	j=0;
    Stevilo=0;
    SteviloTock=0;
    while(!vhod.eof()) //branje do konca
    {
        vhod.get(znak);
        if(znak!=' ' && znak!='\n')//ce preberemo nepomemben podatek
        {
            for(z=0;z<6;z++) cena[z]='\0';//inic. vhodnega bufferja
            z=0;
            while(znak!=' ' && znak!='\n' && !vhod.eof())//branje pomembnih podatkov
            {
                cena[z++]=znak;
                vhod.get(znak);
            }
            cena[z]='\0';
            TabPo[Stevilo].x=i;            //zapis podatkov
		    TabPo[Stevilo].y=j;
		    TabPo[Stevilo].cena=atoi(cena);
            TabPo[Stevilo++].skupina=0;
            if(znak==' ') //prebrali smo element
            {
                j++;
            }
            else          //prebrali smo vrstico
            {
                i++;
                j=0;
                SteviloTock++;
            }
        }
    }
	SteviloTock++;
    vhod.close();
	str.Format("%d vozlišč s %d povezavami prebrana!",SteviloTock,Stevilo);
 	MessageBox(str,"Obvestilo");
    SteviloVneseno=true; 
}
return 0;
}