//Function use: G中删除弧<v,w>,若是无向,还删除<w,v>
Status DeleteArc(MGraph *pG, VertexType v, VertexType w)
{
int nSeqV;
int nSeqW;
nSeqV = LocateVex(*pG, v);
nSeqW = LocateVex(*pG, w);
if (nSeqV < 0 || nSeqW < 0)
{
return ERROR;
}
else
{
if (DN == (*pG).kind || AN == (*pG).kind)
{
(*pG).arcs[nSeqV][nSeqW].adj = INFINITY;
}
else
{
(*pG).arcs[nSeqV][nSeqW].adj = 0;
}
if (NULL != (*pG).arcs[nSeqV][nSeqW].info)
{
free((*pG).arcs[nSeqV][nSeqW].info);
(*pG).arcs[nSeqV][nSeqW].info = NULL;
}
if (AG == (*pG).kind || AN == (*pG).kind)
{
(*pG).arcs[nSeqW][nSeqV].adj = (*pG).arcs[nSeqV][nSeqW].adj;
(*pG).arcs[nSeqW][nSeqV].info = NULL;
}
(*pG).arcnum--;
}
return OK;
}
void CreateUDN(MGraph &G)
{
int i, j, k, IncInfo;
VRType w;
VertexType v1, v2;
printf("请输入无向网G的顶点数,边数,边是否含相关信息(是：1 否：0)：");
scanf("%d,%d,%d", &G.vexnum, &G.arcnum, &IncInfo);
printf("请输入%d个顶点的值(名称<%d个字符)：\n", G.vexnum, MAX_NAME);
for (i = 0; i < G.vexnum; ++i)
Input(G.vexs[i]);
for (i = 0; i < G.vexnum; ++i)
for (j = 0; j < G.vexnum; ++j) {
G.arcs[i][j].adj = INFINITY;
G.arcs[i][j].info = NULL;
}
printf("请输入%d条边的顶点1 顶点2 权值：\n", G.arcnum);
for (k = 0; k < G.arcnum; ++k) {
scanf("%s%s%d%*c", v1.name, v2.name, &w);
i = LocateVex(G, v1);
j = LocateVex(G, v2);
G.arcs[i][j].adj = w;
if (IncInfo)
InputArc(G.arcs[i][j].info);
G.arcs[j][i] = G.arcs[i][j];
}
G.kind = UDN;
}
Status CreateDG(MGraph *G){
int IncInfo;
printf("输入顶点数, 弧数, 其他信息\n");
scanf("%d %d %d", &(*G).vexnum, &(*G).arcnum, &IncInfo);
int i, j, k;
printf("输入顶点\n");
for(i = 0; i < (*G).vexnum; i++){
getchar();
scanf("%c", &(*G).vexs[i]);
}
for(i = 0; i < (*G).vexnum; i++){
for(j = 0; j < (*G).vexnum; j++){
(*G).arcs[i][j].adj = 0;
(*G).arcs[i][j].info = NULL;
}
}
VertexType v1, v2;
int w;
printf("输入弧的初始点和终端点\n");
for(k = 0; k < (*G).arcnum; k++){
getchar();
scanf("%c %c", &v1, &v2);
// printf("%c %c %d\n", v1, v2);
i = LocateVex((*G), v1);
j = LocateVex((*G), v2);
// printf("%d %d %d\n", i, j, w);
(*G).arcs[i][j].adj = 1;
if(IncInfo){
// Input(*(*G).arcs[i][j].info);
}
}
}
Status InsertArc(OLGraph *G,VertexType v,VertexType w)
{ /* 初始条件: 有向图G存在,v和w是G中两个顶点 */
/* 操作结果: 在G中增添弧<v,w> */
int i,j;
int IncInfo;
char str[MAX_Info];
ArcBox *p;
i=LocateVex(*G,v); /* 弧尾的序号 */
j=LocateVex(*G,w); /* 弧头的序号 */
if(i<0||j<0)
return ERROR;
p=(ArcBox *)malloc(sizeof(ArcBox)); /* 生成新结点 */
p->tailvex=i; /* 给新结点赋值 */
p->headvex=j;
p->hlink=(*G). xlist[j].firstin; /* 插在入弧和出弧的链头 */
p->tlink=(*G). xlist[i].firstout;
(*G). xlist[j].firstin=(*G). xlist[i].firstout=p;
(*G). arcnum++; /* 弧数加1 */
printf("要插入的弧是否含有其它信息(是: 1,否: 0): ");
scanf("%d",&IncInfo);
if(IncInfo)
{
printf("请输入该弧的相关信息(<%d个字符): ",MAX_Info);
scanf("%s",str);
p->info=(InfoType *)malloc((strlen(str)+1)*sizeof(InfoType));
strcpy(p->info,str);
}
else
p->info=NULL;
return OK;
}
void CreateDG(MGraph &G)
{
int i, j, k, IncInfo;
VertexType v1, v2;
printf("请输入有向图G的顶点数,弧数,弧是否含相关信息(是：1 否：0)：");
scanf("%d,%d,%d", &G.vexnum, &G.arcnum, &IncInfo);
printf("请输入%d个顶点的值(名称<%d个字符)：\n", G.vexnum, MAX_NAME);
for (i = 0; i < G.vexnum; ++i)
Input(G.vexs[i]);
for (i = 0; i < G.vexnum; ++i)
for (j = 0; j < G.vexnum; ++j) {
G.arcs[i][j].adj = 0;
G.arcs[i][j].info = NULL;
}
printf("请输入%d条弧的弧尾 弧头：\n", G.arcnum);
for (k = 0; k < G.arcnum; ++k) {
scanf("%s%s%*c", v1.name, v2.name);
i = LocateVex(G, v1);
j = LocateVex(G, v2);
G.arcs[i][j].adj = 1;
if (IncInfo)
InputArc(G.arcs[i][j].info);
}
G.kind = DG;
}
Status CreateDG(OLGraph &G) { // 算法7.3
// 采用十字链表存储表示，构造有向图G（G.kind=DG）。
//scanf(&G.vexnum, &G.arcnum, &IncInfo);
int i,j,k;
char v1,v2;
int IncInfo=0;
struct ArcBox *p;
scanfInit(); // 输入初始化
scanf(&G.vexnum, &G.arcnum, &IncInfo); // 自定义输入函数
for (i=0; i<G.vexnum; ++i) { // 构造表头向量
scanf(&G.xlist[i].data); // 输入顶点值
G.xlist[i].firstin = G.xlist[i].firstout = NULL; // 初始化指针
}
for (k=0; k<G.arcnum; ++k) { // 输入各弧并构造十字链表
scanf(&v1, &v2); // 输入一条弧的始点和终点
i=LocateVex(G, v1); j=LocateVex(G, v2); // 确定v1和v2在G中位置
p=(ArcBox *) malloc (sizeof (ArcBox)); // 假定有足够空间
// *p = {i, j, G.xlist[j].firstin, G.xlist[i].firstout, NULL}
// {tailvex, headvex, hlink, tlink, info}
p->tailvex=i;
p->headvex=j;
p->hlink=G.xlist[j].firstin;
p->tlink=G.xlist[j].firstout;
G.xlist[j].firstin = G.xlist[i].firstout = p;
// 完成在入弧和出弧链头的插入
//if (IncInfo) Input(*p->info); // 输入弧含有相关信息，此略!!!
}
return OK;
} // CreateDG
Status InsertArc(AMLGraph *G,VertexType v,VertexType w)
{ /* 初始条件: 无向图G存在,v和W是G中两个顶点 */
/* 操作结果: 在G中增添弧<v,w> */
int i,j,l,IncInfo;
char s[MAX_INFO];
EBox *p;
i=LocateVex(*G,v); /* 一端 */
j=LocateVex(*G,w); /* 另一端 */
if(i<0||j<0)
return ERROR;
p=(EBox*)malloc(sizeof(EBox));
p->mark=unvisited;
p->ivex=i;
p->jvex=j;
p->info=NULL;
p->ilink=(*G).adjmulist[i].firstedge; /* 插在表头 */
(*G).adjmulist[i].firstedge=p;
p->jlink=(*G).adjmulist[j].firstedge; /* 插在表头 */
(*G).adjmulist[j].firstedge=p;
printf("该边是否有相关信息(1:有 0:无): ");
scanf("%d%*c",&IncInfo); /* 吃掉回车符 */
if(IncInfo) /* 边有相关信息 */
{
printf("请输入该边的相关信息(<%d个字符)：",MAX_INFO);
gets(s);
l=strlen(s);
if(l)
{
p->info=(char*)malloc((l+1)*sizeof(char));
strcpy(p->info,s);
}
}
(*G).edgenum++;
return OK;
}
Status CreateUDN(MGraph &G) {// 算法 7.2
// 采用数组（邻接矩阵）表示法，构造无向网G。
int i,j,k,w;
VertexType v1,v2;
printf("G.vexnum :" ); scanf("%d",&G.vexnum);
printf("G.arcnum :"); scanf("%d",&G.arcnum);
getchar(); /*** 加上此句getchar()!!! ***/
// scanf("%d,%d,%d",&G.vexnum, &G.arcnum, &IncInfo);
for (i=0; i<G.vexnum; i++ ) {
printf("G.vexs[%d] : ",i);
scanf("%c",&G.vexs[i]);
getchar();
} // 构造顶点向量
for (i=0; i<G.vexnum; ++i ) // 初始化邻接矩阵
for (j=0; j<G.vexnum; ++j ) {
G.arcs[i][j].adj = INFINITY; //{adj,info}
G.arcs[i][j].info= NULL;
}
for (k=0; k<G.arcnum; ++k ) { // 构造邻接矩阵
printf("v1 (char) : "); scanf("%c", &v1);getchar();
printf("v2 (char) : "); scanf("%c", &v2);getchar();
printf("w (int) : " ); scanf("%d", &w); getchar();
// 输入一条边依附的顶点及权值
i = LocateVex(G, v1); j = LocateVex(G, v2);
// 确定v1和v2在G中位置
G.arcs[i][j].adj = w; // 弧<v1,v2>的权值
// if (IncInfo) scanf(G.arcs[i][j].info); // 输入弧含有相关信息
G.arcs[j][i].adj = G.arcs[i][j].adj; // 置<v1,v2>的对称弧<v2,v1>
}
return OK;
} // CreateUDN
Status CreateUDN(MGraph &G)//无向网
{
int IncInfo;
int i,j,k;
int v1,v2;
int w;//权重
printf("请输入当前顶点数和弧度数:");
scanf("%d%d",&G.vexnum,&G.arcnum);//如果IncInfo，表示弧没有信息
// scanf("%d",&IncInfo);
printf("请依次输入顶点:\n");
for(i=0;i<G.vexnum;i++)
scanf("%d",&G.vexs[i]); //构造顶点向量矩阵
for(i=0;i<G.vexnum;i++)//初始化邻接矩阵
for(j=0;j<G.vexnum;j++)
{
G.arcs[i][j].adj=0;
G.arcs[i][j].info=NULL;
}
printf("请输入两个邻接点及其权重\n");
for(k=0;k<G.arcnum;k++)//根据弧度数输入顶点
{
scanf("%d%d%d",&v1,&v2,&w);
i=LocateVex(G,v1);
j=LocateVex(G,v2);
G.arcs[i][j].adj=w;//给v1和v2赋上权重
G.arcs[j][i].adj=w;
// if(IncInfo)
// scanf("%c",&(*(G.arcs[i][j].info)));
}
return OK;
}//CreateUDN
/**
* 建立有向图十字链表
*/
Status CreateDG(OLGraph &G)
{
int i = 0,j = 0,k = 0;
VertexType v1, v2;
ArcBox *p;
int IncInfo = 0;
printf("输入顶点数、弧数、弧信息标志（空格分隔）:\n");
scanf("%d %d %d", &G.vexnum, &G.arcnum, &IncInfo); //IncInfo为0则不含其他信息
getchar(); //接收最后的换行符
printf("输入%d个表头结点向量:\n", G.vexnum);
for (i = 0; i < G.vexnum; ++i)
{
scanf("%c", &G.xlist[i].data); //输入顶点值
G.xlist[i].firstin = NULL; //初始化指针
G.xlist[i].firstout = NULL;
}
getchar();
for (k = 0; k < G.arcnum; ++k) //输入各弧并构造十字链表
{
printf("输入一条弧的起点和终点：\n");
scanf("%c %c", &v1, &v2); //输入一条弧的始点和终点
getchar();
i = LocateVex(G, v1);
j = LocateVex(G, v2);
p = (ArcBox*)malloc(sizeof(ArcBox));
if (!p)
return OVERFLOW;
*p = { i, j, G.xlist[j].firstin, G.xlist[i].firstout, NULL };
G.xlist[i].firstout = G.xlist[j].firstin = p;
if (IncInfo)
Input(p->info); //若弧含相关信息，输入
}
return OK;
}
//利用邻接多重表存储结构，构造无向图G
void CreateGraph (struct Graph *G)
{
int VertexInfo;//是否含顶点信息
int EdgeInfo;//是否含边信息
int i, j, k;
char s[MAX_INFO];
struct VertexType a, b;
struct EdgeTyle *p;
prinf("请输入无向图G的顶点个数，顶点是否含其他信息（是：1，否：0）：");
scanf("%d%d",G->vexnum, &VertexInfo);
printf("请输入%d个顶点的值\n",G->vexnum);
for (i = 0; i < G->vexnum; i++)
{
scanf("%s", &G->adjmulist[i].data.name);
G->adjmulist[i].firstedge = NULL;
//顶点其他信息
if (VertexInfo)
{
printf("输入该顶点其他信息：\n");
scanf("%s",s);
int length = strlen(s);
if (length)
{
G->adjmulist[i].data.info = (char *) malloc ((length + 1) * sizeof (char));
strcpy(G->adjmulist[i].data.info, s);
}//end if
}//end if
}//end for
printf("请输入边的条数，边是否含其他信息（是：1，否0）：");
scanf("%d%d",G->edgenum, &EdgeInfo);
printf("输入每条边的两个端点以及该边的长度，空格分割\n");
for (k = 0; k < G->edgenum; k++)
{
scanf("%s%s",a.name, b.name);
i = LocateVex(&G, a);
j = LocateVex(&G, b);
p = (struct EdgeTyle *) malloc (sizeof(struct EdgeTyle));
p->ivex = i;
p->jvex = j;
p->info = NULL;
p->ilink = G->adjmulist[i].firstedge;//插在表头
G->adjmulist[i].firstedge = p;
p->jlink = G->adjmulist[j].firstedge;//插在表头
G->adjmulist[j].firstedge = p;
scanf("%d",&p->length);
if (EdgeInfo)
{
printf("输该边其他信息：\n");
scanf("%s",s);
int length = strlen(s);
if (length)
{
p->info = (char *) malloc ((length + 1) * sizeof (char));
strcpy(p->info, s);
}
}//end if
}//end for
}
void InsertArc(MGraph &G,VertexType v,VertexType w)//在G图中添加<v,w>序列
{
int i,j;//获取w和v在矩阵当中的位置
i=LocateVex(G,v);
j=LocateVex(G,w);
G.arcs[i][j].adj=1;
G.arcs[j][i].adj=1;//对称弧
}
Status NextAdjVex(MGraph G,VertexType v,VertexType w)//返回w的的下一个邻接顶点
{
int i=LocateVex(G,v);
int k=LocateVex(G,w);
for(int j=k;j<G.vexnum;j++)
if(G.arcs[i][j].adj==1&&j>k)
return G.vexs[j];
return ERROR;
}
/*
* @description:创建无向图
* @more:分几步来做
1.确定顶点数/弧数
2.确定各个顶点的值
3.初始化邻接矩阵
4.确定邻接矩阵
*/
Status CreateUDG(MGraph *G) {
int i,j,k,infoflag,len;
char c;
//设置一个暂存区和一个临时指针
char str[MAX_INFO];
char *info;
VertexType v1,v2;
len = 0;
//确定顶点数/弧数
printf("please enter vexnum, arcnum is info(1 or 0):");
scanf("%d,%d,%d",&(*G).vexnum,&(*G).arcnum,&infoflag);
//确定各个顶点的值
printf("the value of each vertex:");
for(i = 0;i < (*G).vexnum ; i++)
scanf("%d,",&(*G).vexs[i]);
//初始化邻接矩阵
for(i = 0; i < (*G).vexnum; i++)
for(j = 0;j < (*G).vexnum ; j++) {
(*G).arcs[i][j].adj = 0; //无向图
(*G).arcs[i][j].info = NULL;
}
//确定邻接矩阵
printf("please %d heads and %d tails:\n",(*G).vexnum,(*G).arcnum);
for(k = 0; k < (*G).arcnum; k++) {
scanf("%d,%d",&v1,&v2);
i = LocateVex(*G,v1);
j = LocateVex(*G,v2);
if(i >= 0 && j >= 0)
(*G).arcs[i][j].adj = (*G).arcs[j][i].adj = 1; //无向图,对称矩阵
//如果顶点有附带信息,则输入并申请空间
if(infoflag) {
printf("please enter the info:");
while( (c = getchar()) != '#')
str[len++] = c;
info = (char *) malloc(len * sizeof(char));
str[len] = '\0';
strcpy(info,str);
(*G).arcs[i][j].info = (*G).arcs[j][i].info = info;
}
}
(*G).kind = UDG;
return OK;
}
Status CreateGraph(ALGraph *G)
{ /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */
int i,j,k;
int w; /* 权值 */
VertexType va,vb;
ArcNode *p;
printf("请输入图的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
scanf("%d",&(*G).kind);
printf("请输入图的顶点数,边数: ");
scanf("%d,%d",&(*G).vexnum,&(*G).arcnum);
printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);
for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
{
scanf("%s",(*G).vertices[i].data);
(*G).vertices[i].firstarc=NULL;
}
if((*G).kind==1||(*G).kind==3) /* 网 */
printf("请顺序输入每条弧(边)的权值、弧尾和弧头(以空格作为间隔):\n");
else /* 图 */
printf("请顺序输入每条弧(边)的弧尾和弧头(以空格作为间隔):\n");
for(k=0;k<(*G).arcnum;++k) /* 构造表结点链表 */
{
if((*G).kind==1||(*G).kind==3) /* 网 */
scanf("%d%s%s",&w,va,vb);
else /* 图 */
scanf("%s%s",va,vb);
i=LocateVex(*G,va); /* 弧尾 */
j=LocateVex(*G,vb); /* 弧头 */
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;
if((*G).kind==1||(*G).kind==3) /* 网 */
{
p->info=(int *)malloc(sizeof(int));
*(p->info)=w;
}
else
p->info=NULL; /* 图 */
p->nextarc=(*G).vertices[i].firstarc; /* 插在表头 */
(*G).vertices[i].firstarc=p;
if((*G).kind>=2) /* 无向图或网,产生第二个表结点 */
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=i;
if((*G).kind==3) /* 无向网 */
{
p->info=(int*)malloc(sizeof(int));
*(p->info)=w;
}
else
p->info=NULL; /* 无向图 */
p->nextarc=(*G).vertices[j].firstarc; /* 插在表头 */
(*G).vertices[j].firstarc=p;
}
}
return OK;
}
void CreateGraph(ALGraph *G)
{ /* 采用邻接表存储结构,构造没有相关信息的图G(用一个函数构造4种图) */
int i,j,k;
int w; /* 权值 */
VertexType va,vb;
ArcNode *p;
//printf("Enter the type of map:(0~3): ");
scanf("%d",&(*G).kind);
//printf("Enter Vertex number,Arc number: ");
scanf("%d%d",&(*G).vexnum,&(*G).arcnum);
//printf("Enter %d Vertex :\n",(*G).vexnum);
for(i=0;i<(*G).vexnum;++i) /* 构造顶点向量 */
{
scanf("%s",(*G).vertices[i].data);
(*G).vertices[i].firstarc=NULL;
}
//if((*G).kind==1||(*G).kind==3) /* 网 */
// printf("Enter order every arc weight,head and tail (Takes the gap by the blank space ):\n");
//else /* 图 */
// printf("Enter order every arc head and tail (Takes the gap by the blank space ):\n");
for(k=0;k<(*G).arcnum;++k) /* 构造表结点链表 */
{
if((*G).kind==1||(*G).kind==3) /* 网 */
scanf("%d%s%s",&w,va,vb);
else /* 图 */
scanf("%s%s",va,vb);
i=LocateVex(*G,va); /* 弧尾 */
j=LocateVex(*G,vb); /* 弧头 */
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;
if((*G).kind==1||(*G).kind==3) /* 网 */
{
p->info=(int *)malloc(sizeof(int));
*(p->info)=w;
}
else
p->info=NULL; /* 图 */
p->nextarc=(*G).vertices[i].firstarc; /* 插在表头 */
(*G).vertices[i].firstarc=p;
if((*G).kind>=2) /* 无向图或网,产生第二个表结点 */
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=i;
if((*G).kind==3) /* 无向网 */
{
p->info=(int*)malloc(sizeof(int));
*(p->info)=w;
}
else
p->info=NULL; /* 无向图 */
p->nextarc=(*G).vertices[j].firstarc; /* 插在表头 */
(*G).vertices[j].firstarc=p;
}
}
}
void DeleteArc(MGraph &G,VertexType v,VertexType w)
{
//删除弧<v,w>,若G是无向的则还需删除对称弧<w,v>
int i,j;
G.vexnum-=2;
G.arcnum-=1;
i=LocateVex(G,v);
j=LocateVex(G,w);
G.arcs[i][j].adj=0;
G.arcs[j][i].adj=0;
}
Status CreateUDN(MGraph *G) {
int i,j,k,len,infoflag,w;
VertexType v1,v2;
char str[MAX_INFO];
char *info;
char c;
//确定顶点数/弧数
printf("please enter vexnum , arcnum and is info(1 or 0):");
scanf("%d,%d,%d",&(*G).vexnum,&(*G).arcnum,&infoflag);
//确定各个顶点的值
printf("the value of each vertex:");
for(i = 0;i < (*G).vexnum ; i++)
scanf("%d,",&(*G).vexs[i]);
//初始化邻接矩阵
for(i = 0; i < (*G).vexnum; i++)
for(j = 0;j < (*G).vexnum ; j++) {
(*G).arcs[i][j].adj = INFINITY; //无向网
(*G).arcs[i][j].info = NULL;
}
//确定邻接矩阵
printf("please heads,tails and weights:\n");
for(k = 0; k < (*G).arcnum; k++) {
scanf("%d,%d,%d",&v1,&v2,&w);
i = LocateVex(*G,v1);
j = LocateVex(*G,v2);
if(i >= 0 && j >= 0)
(*G).arcs[i][j].adj = (*G).arcs[j][i].adj = w; //无向网
//如果顶点有附带信息,则输入并申请空间
if(infoflag) {
printf("please enter the info:");
while( (c = getchar()) != '#')
str[len++] = c;
info = (char *) malloc(len * sizeof(char));
strcpy(info,str);
(*G).arcs[i][j].info = info;
}
}
(*G).kind = UDN;
return OK;
}
Status CreateGraph(ALGraph &G){
//G.kind---- 0:DG 1:DN 2:UDG 3:UDN
scanf("%d%d%d\n",&G.vexnum,&G.arcnum,&G.kind);
if(G.kind > 3 || G.kind < 0){
Error(" Incorrect graph kind input. the legal number must between 0 and 3.");
return ERROR;
}
int i,j,k;
EdgeType weight;
ArcNode *pi,*pj;
VertexType sv,ev;
for(i = 0; i < G.vexnum; i++) { //Construct vertex nodes.Input vertex data and init adjlist head pointer.
scanf("%c\n", &G.vertices[i].data);
G.vertices[i].firstarc = NULL;
G.vertices[i].visited = 0; //set unvisited
}//for
for(k = 0; k < G.arcnum; k++) { //Construct arc.Input head and tail of an edge.
scanf("%c %c\n",&sv,&ev);
// locate index of sv and ev
i = LocateVex(G,sv);
j = LocateVex(G,ev);
pi = (ArcNode *)malloc(sizeof(ArcNode));
if(!pi){
Error("out of space");
return ERROR;
}//if
pi->adjvex = j;
// edge's weight info
if(G.kind == DN || G.kind == UDN) {
scanf("%d\n",&weight);
}
else
weight = 0;
//Head insert to construct vertices[i]'s adjlist.
pi->weight = weight;
pi->nextarc = G.vertices[i].firstarc;
G.vertices[i].firstarc = pi;
if(G.kind == UDG || G.kind == UDN) {
//Construct vertices[j]'s adjlist in the light of symmetry in UDG/UDN.
pj = (ArcNode *)malloc(sizeof(ArcNode));
if(!pj){
Error("out of space");
return ERROR;
}//if
pj->adjvex = i;
pj->weight = weight;
pj->nextarc = G.vertices[j].firstarc;
G.vertices[j].firstarc = pj;
}//if
}//for
return OK;
}//CreateGraph
void DeleteArc(MGraph &G,VertexType v,VertexType w)
{
//删除弧<v,w>,若G是无向的则还需删除对称弧<w,v>
int i,j;
G.vexnum-=2;
G.arcnum-=1;
i=LocateVex(G,v);
j=LocateVex(G,w);
G.arcs[i][j].adj=0;
if(G.kind==UDN||G.kind==UDG)//如果是无向图或者无向网，删除对称偶序
G.arcs[j][i].adj=0;
}
void DFS(MGraph G,VertexType v)
{
VertexType w;
int i=LocateVex(G,v);
if(!Visited[i])
{
Visited[i]=TRUE;
Visit(v);
}
for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w))
if(!Visited[LocateVex(G,w)])
DFS(G,w);
}
Status CreateUDG(ALGrapth *G){
int IncInfo;
printf("输入顶点数, 弧数, 其他信息\n");
scanf("%d %d %d", &(*G).vexnum, &(*G).arcnum, &IncInfo);
int i, j, k;
printf("输入顶点\n");
for(i = 0; i < (*G).vexnum; i++){
getchar();
scanf("%c", &(*G).vertices[i].data);
(*G).vertices[i].firstarc = NULL;
}
// for(i = 0; i < (*G).vexnum; i++){
// printf("%c\n", (*G).vertices[i].data);
// }
VertexType v1, v2;
int w;
printf("输入弧的初始点和终端点\n");
for(k = 0; k < (2 * (*G).arcnum); k++){
getchar();
scanf("%c %c", &v1, &v2);
// printf("%c %c %d\n", v1, v2);
i = LocateVex((*G), v1);
j = LocateVex((*G), v2);
// printf("%d %d\n", i, j);
ArcNode *an;
an = (ArcNode*)malloc(sizeof(ArcNode));
an->adjvex = j;
an->nextarc = NULL;
// printf("test1\n");
if((*G).vertices[i].firstarc){
ArcNode *last = (*G).vertices[i].firstarc;
// printf("test2\n");
while(last->nextarc) last = last->nextarc;
// printf("test3\n");
last->nextarc = an;
// printf("test4\n");
}else{
(*G).vertices[i].firstarc = an;
}
if(IncInfo){
// Input(*(*G).arcs[i][j].info);
}
}
}
Status CreateUDG( AMLGraph *G )
{
int k , l ;
int i , j ;
int IncInfo ;
InfoType str[ MAX_INFO ] ;
EBox *p ;
VertexType va , vb ;
printf( "Input the number of vex,arc and wether exist information(0 means no):" ) ;
scanf( "%d%d%d%*c" , &( *G ).vexnum , &( *G ).edgenum , &IncInfo ) ; //IncInfo为0 则各弧不含有其他信息
printf( "Please input the vector of the vex:\n" ) ;
for( k = 0 ; k < ( *G ).vexnum ; ++ k ) //构造顶点值
{
scanf( "%s" , &( *G ).adjmulist[ k ].data ) ;
( *G ).adjmulist[ k ].firstedge = NULL ; //初始化指针
}
printf( "Please input the edge of AMLGraph:\n" ) ;
for( k = 0 ; k < ( *G ).edgenum ; ++ k ) //出入弧并构造十字链表
{
scanf( "%s%s" , va , vb ) ;
i = LocateVex( *G , va ) ; //va<----->vb
j = LocateVex( *G , vb ) ;
p = ( EBox *)malloc( sizeof( EBox ) ) ;
p->mark = unvisited ; //Take care!
p->ivex = i ;
p->jvex = j ;
p->info = NULL ;
p->ilink = ( *G ).adjmulist[ i ].firstedge ;
( *G ).adjmulist[ i ].firstedge = p ;
p->jlink = ( *G ).adjmulist[ j ].firstedge ;
( *G ).adjmulist[ j ].firstedge = p ;
if( IncInfo )
{
printf( "Please input the information about this arc( %d char ):" , MAX_INFO ) ;
scanf( "%s" , str ) ;
l = strlen( str ) ;
if( l )
{
p->info = ( char * )malloc( ( l + 1 ) * sizeof( char ) ) ; //( l + 1 )
strcpy( p->info , str ) ;
}
}
}//for k
return OK ;
}
int NextAdjVex(MGraph G, VertexType v, VertexType w)
{/* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号, */
/* 若w是v的最后一个邻接顶点,则返回-1 */
int i, j = 0, k1, k2;
k1 = LocateVex(G, v);
k2 = LocateVex(G, w);
if (G.kind == DN || G.kind == AN) j = INFINITY;
for (i = k2 + 1; i < G.vexnum; i++) {
if (G.arcs[k1][i].adj != j) {
return i;
}
}
return -1;
}
//Function use: 邻接矩阵表示法,构造有向网G
Status CreateDN(MGraph *pG)
{
int i;
int j;
int k;
VRType nWeight;
int nLength;
boolean bInfo;
InfoType s[MAX_INFO];
InfoType *info;
VertexType va;
VertexType vb;
printf("请输入有向网G的顶点数,弧数,弧是否其它信息(是:1,否:0):");
scanf("%d%d%d", &(*pG).vexnum, &(*pG).arcnum, &bInfo);
printf("请输入%d个顶点的值(<%d个字符):\n", (*pG).vexnum, MAX_NAME);
//构造顶点向量
for (i = 0; i < (*pG).vexnum; i++)
{
scanf("%s", (*pG).vexs[i]);
}
//初始化邻接矩阵
memset((*pG).arcs, INFINITY, (*pG).vexnum * (*pG).vexnum\
* sizeof(ArcCell));
//构造有向网
printf("请输入%d条弧的弧尾 弧头 权值(空格隔开):", (*pG).arcnum);
for (k = 0; k < (*pG).arcnum; k++)
{
scanf("%s%s%d%*c", va, vb, &nWeight);
i = LocateVex((*pG), va);
j = LocateVex((*pG), vb);
(*pG).arcs[i][j].adj = nWeight;
if (bInfo)
{
printf("请输入该弧的相关信息(<%d个字符):", MAX_INFO);
fgets(s, MAX_INFO, stdin);
nLength = strlen(s);
if (0 != nLength)
{
info = (char *)malloc((nLength + 1) * sizeof(char));
strcpy(info, s);
(*pG).arcs[i][j].info = info;
}
}
}
(*pG).kind = DN;
return OK;
}
//Function use: 在G中增加弧<v,w>, 若是无向的,另增加<w,v>
Status InsertArc(MGraph *pG, VertexType v, VertexType w)
{
int i;
int nLength;
InfoType *info;
InfoType s[MAX_INFO];
int nSeqV = LocateVex(*pG, v);
int nSeqW = LocateVex(*pG, w);
if (nSeqV < 0 || nSeqW < 0)
{
perror("No such Vertex!\n");
return ERROR;
}
else
{
(*pG).arcnum++;
if (DN == (*pG).kind || AN == (*pG).kind)
{
printf("请输入此弧或边的权值:");
scanf("%d", &(*pG).arcs[nSeqV][nSeqW].adj);
}
else
{
(*pG).arcs[nSeqV][nSeqW].adj = 1;
}
printf("是否有相关信息?(0:无 1:有):");
scanf("%d%*c", &i);
if (1 == i)
{
printf("请输入相关信息:");
fgets(s, MAX_INFO, stdin);
nLength = strlen(s);
if (0 != nLength)
{
info = (InfoType*)malloc((nLength + 1) * sizeof(InfoType));
strcpy(info, s);
(*pG).arcs[nSeqV][nSeqW].info = info;
}
}
if ((*pG).kind > 1) //无向
{
(*pG).arcs[nSeqW][nSeqV].adj = (*pG).arcs[nSeqV][nSeqW].adj;
(*pG).arcs[nSeqW][nSeqV].info = (*pG).arcs[nSeqV][nSeqW].info;
}
}
return OK;
}
//Function use: 邻接矩阵构造无向网
Status CreateAN(MGraph *pG)
{
int i;
int j;
int k;
VRType nWeight;
InfoType s[MAX_INFO];
VertexType va; //顶点1和顶点2
VertexType vb;
boolean bInfo; //是否有相关信息
int nLength; //相关信息长度
printf("请输入无向网的顶点数 边数 边是否有相关信息:");
scanf("%d%d%d", &(*pG).vexnum, &(*pG).arcnum, &bInfo);
//构造顶点向量
printf("请输入%d个顶点值:", (*pG).vexnum);
for (i = 0; i < (*pG).vexnum; i++)
{
scanf("%s%*c", (*pG).vexs[i]);
}
//初始化邻接矩阵
memset((*pG).arcs, INFINITY, (*pG).vexnum * (*pG).vexnum\
* sizeof(ArcCell));
//构造边
printf("请输入顶点1 顶点2 权值:");
for (k = 0; k < (*pG).arcnum; k++)
{
scanf("%s%s%d%*c", va, vb, &nWeight);
i = LocateVex(*pG, va);
j = LocateVex(*pG, vb);
(*pG).arcs[i][j].adj = nWeight;
if (bInfo)
{
printf("请输入该边的相关信息:");
fgets(s, MAX_INFO, stdin);
nLength = strlen(s);
if (0 != nLength)
{
(*pG).arcs[i][j].info = (InfoType*)malloc(\
(nLength + 1) * sizeof(InfoType));
strcpy((*pG).arcs[i][j].info, s);
(*pG).arcs[j][i].info = (*pG).arcs[i][j].info;
}
}
}
(*pG).kind = AN;
return OK;
}
Status FirstAdjVex( AMLGraph G , VertexType u ) //返回u的第一个邻接点
{
int k ;
EBox *p ;
k = LocateVex( G , u ) ;
if( k < 0 )
exit( OVERFLOW ) ;
p = G.adjmulist[ k ].firstedge ;
if( p )
{
if( p->ivex == k )
{
// puts( G.adjmulist[ p->jvex ].data ) ;
return p->jvex ;
}
else //p->jvex == k
{
// puts( G.adjmulist[ p->ivex ].data ) ;
return p->ivex ;
}
}
return EOF ;
}
Status DijShortPath(ALGraph graph, int v, int path[][MAXVEX + 1], int *dist) {
int index;
int index2;
int i, j, k;
int mindist;
int distance;
int final[MAXVEX];
if (graph.vexnum == 0)
return ERROR;
if ((index = LocateVex(graph, v)) == -1)
return ERROR;
if (path == NULL || dist == NULL)
return ERROR;
for (i = 0; i < graph.vexnum; i++) {
final[i] = false;
dist[i] = Distance(graph, index, i);
path[i][0] = 0;
if (dist[i] != MAXINT) {
path[i][0]++;
path[i][1] = v;
}
}
path[index][0] = 1; //path的存储结构为path[0]=length表示点的个数
path[index][1] = v; //接下来length个元素为顶点
final[index] = true;
void MiniSpanTree_PRIM (MGraph G,VertexType u)
{
/*用普利姆算法从第u个顶点出发构造网G 的最小生成树T,输出T的各条边。
* 记录从顶点集U到V-U的代价最小的边的辅助数组定义：
* struct
{
VertexType adjvex;
VRtype lowcost;
}closedge[MAX_VERTEX_NUM];
*/
k = LocateVex ( G , u );
for (j= 0 ;j<G.vexnum; j++) //辅助数组初始化
{
if (j!=k)
closedge[j] = {u,G.arcs[k][j].adj};//{adjvex,lowcost}
}
closedge[k].lowcost = 0 ; //初始，U={u}
for( i=1; i<G.vexnum ;i++) //选择其余G.vexnum -1 个顶点
{
k = minimum(closedge); //求出T的下个结点：第k结点
/*此时 closedge[k].lowcost = MIN{ closedge[Vi].lowcost|closedge[Vi].lowcost>0,Vi∈V-U}
*/
printf(closedge[k].adjvex,G.vexs[k]); //输出生成树的边
closedge[k].lowcost = 0; //第k条边并入U集
for ( j=0;j<G.vexnum ;j++)
{
if ( G.arcs[k][j].adj < closedge[j].lowcost) //新顶点并入U后重新选择最小边
closedge[j] = {G.vex[k],G.arcs[k][j].adj};
}
}
}
