Prim algorithm of minimum spanning tree

Prim algorithm:if n = (v. {E}) is a connected network, and Te is a collection of edges in the smallest spanning tree on N. The algorithm starts with u={u0} (u0 belongs to V), te={}, and repeatedly runs the following operations: in the all U belongs to the u,v belongs to the v-u side (u,v) belongs to E to find a cost the least side (U0,V0) into the set TE, at the same time v0 into U, until u=v, There must be a n-1 edge in Te, then t= (v. {TE}) is the smallest spanning tree of N. To implement this algorithm, an auxiliary array Closedge is attached to record the lowest-cost edge from U to v-u.

For each vertex vi belongs to V-u, there is a corresponding component in the auxiliary array Closedge[i-1], which contains two domains, the Lowcost domain stores the right of that edge, and the Vex domain stores the vertices in U that the edge is attached to.

Consider for example the following non-net:

Adjacency Matrix:

Its minimum spanning tree is:

Prim algorithm process (the graph is represented by an adjacency matrix, if starting from Vertex a):
1. First initialize the auxiliary array and the vertex u into the U-set:

2. Iterate n-1 times, N is the number of vertices, each iteration calls the Mininum method to return a minimum k value, then outputs the edge of the spanning tree, and the K vertex is included in the U-set, and the secondary array is updated last.

For example, the first cycle. K = 2 (very clearly the minimum weight is 1=min{6,1,5}, the sequence number is 2, that is, K = 2), the edge of the output spanning tree (a,c), the adjacency matrix K vertex into the U-set (vertex C), will be lowcost 0, at this time the corresponding auxiliary array such as the following:

Watermark/2/text/ahr0cdovl2jsb2cuy3nkbi5uzxqvy2hkamo=/font/5a6l5l2t/fontsize/400/fill/i0jbqkfcma==/dissolve/70 /gravity/center ">

The following will update the auxiliary array, that is, the elements of the auxiliary array and the adjacent table K line, if the corresponding value of the adjacency table is small, then replace the auxiliary array value.

At this point the first cycle ends, the following enters the second cycle, when k = 5 ...
implementation:

/**********************************************prim algorithm to find the minimum spanning tree by rowandjj2014/7/1********************************* /#include <iostream>using namespace std;//---------------------------------------#define Max_ Vertex_num 20//Edge max. # define Infinty 65535//represents infinity typedef struct _arc_{int adj;//vertex relationship type char *info;//arc information}arc,adjmatri    x[max_vertex_num][max_vertex_num];typedef struct _graph_{char vexs[max_vertex_num];//vertex vector adjmatrix arcs;//adjacency matrix int vexnum,arcnum;//number of vertices, arcs}graph;//----------------------------------------typedef struct _ARRAY_//Auxiliary array {Char adjvex;//storage vertex int lowcost;//storage weights}minside[max_vertex_num];//----------------------------------------//figure operation INT Locatevex (graph G,char u); bool Createan (graph *g);//construct the non-network void Display (graph G);//Print the non-net//prim algorithm void Minispantree_prim ( Graph g,char u);//Use the PRIMM algorithm to construct the minimum spanning tree T of net G from the U-vertex, the output t of each edge int mininum (minside sz,graph G);//The minimum positive value for closedge.lowcost//------   ---------------------------------int Locatevex (Graph g,char u) {int i; for (i = 0; i < G.vexnum; i++) {if (g.vexs[i] = = u) {return i; }} return-1;}    BOOL Createan (Graph *g) {int i,j,k;    int incinfo;    char va,vb;//vertex int w;//right char *info;    Char str[20];    cout<< "Please enter the number of vertices of the non-net g, the number of edges, whether the edge contains other information (yes: 1, no: 0): \ n";    cin>>g->vexnum;    cin>>g->arcnum;    cin>>incinfo;    cout<< "The value of the input vertex:";    Initialize vertex for (i = 0; i < g->vexnum; i++) {cin>>g->vexs[i];            }//Initialize adjacency matrix for (i = 0; i < g->vexnum; i++) {for (j = 0; J < g->vexnum; J + +) {            G->arcs[i][j].adj = Infinty;        G->arcs[i][j].info = NULL;    }} cout<< "Enter two vertices and weights for each edge in turn" <<endl;        Initialize Edge for (k = 0; k < g->arcnum; k++) {cin>>va;        cin>>vb;        cin>>w;        i = Locatevex (*g,va);        j = Locatevex (*G,VB);        G->arcs[i][j].adj = W;   G->arcs[j][i].adj = W;     if (incinfo)//ARC Information {cout<< "Enter information about this edge:";            cin>>str;            w = strlen (str) +1;                if (w) {info = (char *) malloc (sizeof (char) * (w+1));                strcpy (INFO,STR);            G->arcs[i][j].info = G->arcs[j][i].info = info; }}} return true;    void Display (Graph G) {int i,j;    cout<< "vertex:";    for (i = 0; i < G.vexnum; i++) {cout<<g.vexs[i]<< "";    } cout<< "\ n adjacency matrix: \ n"; for (i = 0; i < G.vexnum; i++) {for (j = 0; J < G.vexnum; J + +) {Cout<<g.arcs[i][j]        .adj<< "";    } cout<<endl; } Cout<<endl;}    ---------------------------------------------------------int mininum (minside sz,graph G) {int i = 0,J; The int min;//stores the smallest weight int k;//The element in the array where the smallest value is stored while (!    Sz[i].lowcost)//Ignore the element {i++, lowcost is 0;    } min = Sz[i].lowcost;    K = i; For (j= i+1; j< G.vexnum; J + +) {if (Sz[j].lowcost > 0 && min > Sz[j].lowcost)//ignore element of Lowcost = 0 {min = sz[j            ].lowcost;        K = J; }} return k;}    void Minispantree_prim (Graph g,char u) {minside closedge;//auxiliary array int i,j,k;    K = Locatevex (g,u);    if (k==-1) {return; }//Initialize auxiliary array for (i = 0; i < G.vexnum; i++) {if (k! = i) {Closedge[i].adjvex = u;//copy Top Point closedge[i].lowcost = g.arcs[k][i].adj;//copy Right}} closedge[k].lowcost = 0;//Initial, the K vertex is included in the U-set cout&    lt;< "The minimum cost spanning tree's edges are: \ n";        for (i = 1; i < g.vexnum; i++) The minimum spanning tree of//n vertices is the n-1 edge {k = Mininum (closedge,g); cout<<closedge[k].adjvex<< "--->" <<g.vexs[k]<<endl;//outputs the edge of the spanning tree closedge[k].lowcost = 0;//k vertex incorporates U-set//update auxiliary array for (j = 0; J < G.vexnum; J + +) {if (closedge[j].lowcost          > G.arcs[k][j].adj) {      Closedge[j].adjvex = g.vexs[k];//Update top name closedge[j].lowcost = g.arcs[k][j].adj;//Update Right} }} Cout<<endl;}    ---------------------------------------------------------int main () {Graph g;    Createan (&AMP;G);    Display (g);    Minispantree_prim (g, ' a '); return 0;}

Test:

Prim algorithm of minimum spanning tree