图（基本算法）

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <queue>
#include <limits.h>

using namespace std;

#define MAXNUM 26

typedef struct
{
int adjvex;
int lowcost;
}minside[MAXNUM];//求最小生成树的辅助数组

struct VertexType
{
char name[20];
};
/* struct ArcNode
{
int site;
int * info;
ArcNode * nextarc;
};

typedef struct
{
VertexType data;
ArcNode * first;
}Adjlist[MAXNUM];

struct ALGraph
{
Adjlist vertice;
int number;
int hushu;
}; 邻接表 */

struct side
{
int a, b;
VRType weight;
};
typedef struct
{
VRtype adj;
InfoType * info;
}ArcCell, AdjMatrix[MAXNUM][MAXNUM];
struct MGraph
{
VertexType vex[MAXNUM];
AdjMatrix arcs;
int vexnum, arcnum;
};
void CreatUDC(MGraph &G)
{
int i, j, k, IncInfo, w;
VertexType v1, v2;
cin >> G.vexnum >> G.arcnum;
for(i = 0; i < G.vexnum; i++)
cin >> vex[i].name;
for(i = 0; i < G.vexnum; i++)
for(j = 0; j < G.vexnum; j++)
{
G.arcs[i][j].adj = INT_MAX;
G.arcs[i][j].info = NULL;
}
for(int k = 0; k < G.vexnum; k++){
cin >> v1.name >> v2.name >> w;
i = LocateVex(G, v1);
j = LocateVex(G, v2);
G.arcs[i][j] = w;
G.arcs[i][j] = w;}

}
int LocateVex(ALGraph * G, VertexType u)
{
int i;
for(i = 0; i < G->number; i++)
if(!strcmp(G->vertice[i].data, u->data))
return i;
return -1;
}
/*头插法
void LinkList(ArcNode *L1, ArcNode e)
{
ArcNode *p = L1;
L1 = &e;
e.nextarc = p;
}
百度*/
void creatGraph(ALGraph * G)//无向图 邻接表
{
VertexType v1, v2;
ArcNode e;
cin >> G->number >> G->hushu;
for(int i = 0;i < G->number; i++)
{
cin >> G->vertice[i].data.name;
G->vertice[i].first = NULL;
}
for(int k = 0;k < G->hushu; k++)
{
int i, j;
cin >> v1 >> v2;
i = Locate(G, v1); //弧尾
j = Locate(G, v2); //弧头
e.info = NULL;
e.site = j;
LinkList(G->vertice[i].first, e);
/*e.site = i;
LinkList(G->vertice[j].first, e);
*/
}

}

int FirstAdjVex(ALGraph G, int v) //返回第一个v的第一个临接顶点的序号
{
ArcNode * p = G.vertice[v].first;
if(p)
return p->site;
else
return -1;
}

int NextAdjVex(ALGraph G, int v, int w) //v是G某个点的序号，w是他的领接顶点序号
{
LinkList p, p1;
int e = w;
p = Point(G.vertice[v].first, e, equalvex, p1);
if(!p || !p->next)
return -1;
else
return p->next->site;;
}

void DFSTraverse(Graph G, void(*Vist)(Vertextype))
{
int v;
for(v = 0; v < G.number; v++)
visite[v] = 0;
for(v = 0; v < G.number; v++)
if(!visite[v])
DFS(G, v);
}
void DFS(Graph G, int v)
{
int w;
visite[v] = 1;
cout << G.vertice[v].data.name;
for(w = FirstAdjvex(G, v); w > 0; w = NextAdjVex(G, v, w))
if(!visite[w])
DFS(G, w);
}

void BFSTraverse(Graph G, void(*Vist)(Vertextype))
{
for(int v = 0; v < G.number; v++)
visite[v] = 0;
queue<int> Q;
for(int v = 0; v < G.number; v++)
if(!visite[v])
{
visite[v] = 1;
visit(v);
Q.push(v);
while(!Q.empty())
{
Q.pop();
for(w = FirstAdjvex(G, v); w > 0; w = NextAdjVex(G, v, w))
if(!visite[v])
{
visit(v);
visite[v] = 1;
Q.push(v);
}
}
}
}

//最小生成树
int mininum(minside SZ, MGraph G)
{
int i = 0, j, k, min;
while(!SZ[i].lowcost)
i++;
min = SZ[i].lowcost;
k = i;
for(j = i + 1; j < G.vexnum; j++)
if(SZ[j].lowcost > 0 && SZ[i].lowcost < min)
min = SZ[i].lowcost, k = j;
return k;
}
void MiniSpanTree_Prim(MGraph G, VertexType u)
/*从顶点u出发， 按普里姆算法构造连通网G 的最小生成树， 并输出生成树的每条边*/
{
minside closedge;
int i, j, k;
k=LocateVertex(G, u);  // k = LocateVex(G, u);
for (j=0; j<G.vexnum; j++) 
if ( j! =k) closedge[j]={k, G.arcs[k][j].adj};
closedge[k].lowcost=0;
for (i=1; i<G.vexnum; i++) {
k=Minimum(closedge, G);
printf("%s - %s ", G.Vex[closedge[k].adjvex].name, G.vexs[k].name); /*输出生成树的当前最小边*/
 closedge[k].lowcost=0; /*将顶点k纳入U集合*/
for ( j=0 ; j < G.vexnum; j++) /*在顶点v0并入U之后， 更新closedge[j] */
if ( G.arcs[k][j].adj <closedge[j].lowcost)
closedge[j]={G.vexs[k], G.arcs[k][j].adj}; 
}//for
} //minispantree_prim
// 初始化并查集

 

转载于:https://www.cnblogs.com/qq756648174/p/5682495.html