（程序出错）关于用邻接多重表实现图的深度优先遍历和广度优先遍历

[JMcico]

题目要求：以邻接多重表为存储结构，实现连通无向图的深度优先遍历和广度优先遍历。以指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。
主要是在调试过程中曾出现以下几个错误：
1.图的构建成功，但调用两种遍历函数的时候输出为“烫烫烫”。
2.没有输出完所有的顶点
3.构建图后弹出“Run-Time Check Failure #2 - Stack around the variable 'G' was corrupted.”的警告
由于本身编程能力不足，还望各路大神不吝赐教，谢谢！

以下为程序源代码：

//————程序名：图的遍历————//
/******头文件及定义******/
#include<iostream>
#include<string.h>
#include<queue>
#include<stdio.h>
using namespace std;
#define ERROR 0
#define OK 1
#define MAX_VERTEX_NUM 30 //最大顶点数量为30
typedef int status;


/******定义图的邻接多重表结构******/
typedef struct ebox
{
int ivex,jvex; //该边依附的两个顶点位置
struct ebox *ilink,*jlink; //分别指向依附这两个顶点的下一条边
}ebox;

typedef struct vexbox
{
char data[100]; //存储顶点信息
ebox *firstage; //指向第一条依附该顶点的边
}vexbox;

typedef struct
{
vexbox vexes[MAX_VERTEX_NUM];
int vexnum,edgenum; //无向图的当前顶点数和边数
}AMLGraph;

/*若G中存在顶点a，则返回该顶点在图中的位置*/
int LocateVex(AMLGraph G,char a[100])
{
int i;
for(i=1;i<=G.vexnum;++i)
{
if(strcmp(a,G.vexes[i].data)==0)
return i;
}
return -1;
}


/******图的构建******/

void CreateGraph(AMLGraph &G)
{
char v1[20],v2[20];
int i,j,k;
ebox *p;

cout<<"请输入图的顶点数和弧数："<<endl;
cin>>G.vexnum;
cin>>G.edgenum;
cout<<"请输入顶点："<<endl;

for(i=1;i<=G.vexnum;++i) //初始化顶点
{
cin>>G.vexes[i].data;
G.vexes[i].firstage=NULL;
}

cout<<"请输入弧尾和弧头："<<endl;
for(k=1;k<=G.edgenum;++k)
{
cin>>v1[k];
cin>>v2[k];

p=(ebox*)malloc(sizeof(ebox));

i=LocateVex(G,v1);
p->ivex=i;
j=LocateVex(G,v2);
p->jvex=j;
p->ilink=G.vexes[i].firstage; //插在表头
G.vexes[i].firstage=p;
p->jlink=G.vexes[j].firstage; //插在表头
G.vexes[j].firstage=p;
}
}


/******寻找v的第一个邻接点w******/
int FirstAdjVex(AMLGraph G,int v)
{
if(v<0) //G中不存在顶点v
return -1;
if(G.vexes[v].firstage) //v有邻接顶点
if(G.vexes[v].firstage->ivex==v)
return G.vexes[v].firstage->jvex;
else
return G.vexes[v].firstage->ivex;
else
return -1;
}


/******返回v的下一个邻接点******/
int NextAdjVex(AMLGraph G,int v,int w)
{
ebox *p;

if(v<0||w<0) //v或w不是G中的顶点
return -1;

p=G.vexes[v].firstage; //p指向顶点v的第一条边

while(p)
{
if(p->ivex==v && p->jvex!=w) //v和w不是邻接点（第一种情况）
p=p->ilink; //找下一个邻接顶点
else if(p->jvex==v &&p->ivex!=w) //v和w不是邻接点（第二种情况）
p=p->jlink; //找下一个邻接结点
else //是邻接顶点w
break;
}

if(p && p->ivex==v && p->jvex==w) //找到邻接顶点w（第一种情况）
{
p=p->ilink;
if(p && p->ivex==v)
return p->jvex;
else if(p && p->jvex==v)
return p->ivex;
}

if(p && p->ivex==w && p->jvex==v) //找到邻接顶点w（第二种情况）
{
p=p->jlink;
if(p && p->ivex==v)
return p->jvex;
else if(p && p->jvex==v)
return p->ivex;
}
return -1;
}


/*访问顶点*/
void VisitFuc(AMLGraph G,int v)
{
cout<<G.vexes[v].data<<" ";
}


/*标记数组*/
int visited[MAX_VERTEX_NUM+1];


/******图的深度优先遍历******/

/*从第v个顶点出发递归深度优先遍历图*/
void DFS(AMLGraph G,int v)
{
int w,p=1;
visited[v]=1;
VisitFuc(G,v);
for(w=FirstAdjVex(G,v);w>0;w=NextAdjVex(G,v,w))
if(!visited[w]) //对没访问过的点调用DFS()函数
DFS(G,w);

}

void DFSTraverse(AMLGraph G,int v)
{
int i;
for(i=1;i<=G.vexnum;i++)
visited[i]=0; //初始化每个标记数组元素
DFS(G,v);
}


/******图的广度优先遍历******/

/*队列的链式存储结构*/
typedef struct qnode
{
int data;
struct qnode *next;
}qnode,*queueptr;

typedef struct
{
queueptr front; //队头指针
queueptr rear; //队尾指针
}linkqueue;


/*构造空队列*/
status InitQueue(linkqueue &Q)
{
Q.front=Q.rear=(queueptr)malloc(sizeof(qnode));
if(!Q.front)
exit(0);
Q.front->next=NULL;
return OK;
}

status QueueEmpty(linkqueue Q) //q为空时返回True，否则返回False
{
if(Q.front==Q.rear)
return OK;
else
return ERROR;
}

/*插入元素e为队列q的队尾元素*/
status EnQueue(linkqueue &Q,int e)
{
queueptr p=(queueptr)malloc(sizeof(qnode));
if(!p) //如果存储分配失败
exit(0);
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}

/*若队列不空，删除q的队头元素，用e返回其值*/
status DeQueue(linkqueue &Q)
{
int e;
queueptr p;
if(Q.front==Q.rear)
return ERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return e;
}

/*销毁队列*/
status DestroyQueue(linkqueue &Q)
{
while(Q.front)
{
Q.rear=Q.front->next;
free(Q.front);
Q.front=Q.rear;
}
return OK;
}

/*广度优先遍历*/
void BFSTraverse(AMLGraph G,int v)
{
int i,u,w;
linkqueue Q;
for(i=1;i<=G.vexnum;i++)
visited[i]=0;
InitQueue(Q); //置空队列

visited[v]=1; //把v标记成已访问
VisitFuc(G,v); //访问v
EnQueue(Q,v); //v入队列
while(!QueueEmpty(Q))
{
u=DeQueue(Q); //队头元素出列赋值给u
for(w=FirstAdjVex(G,u);w>0;w=NextAdjVex(G,u,w))
if(!visited[w]) //w未访问
{
visited[w]=1;
VisitFuc(G,w);
EnQueue(Q,w);
}
}

}


/******主函数******/

void main()
{
int v;
char vd[20];
AMLGraph G;

CreateGraph(G);
cout<<"图创建完毕\n ";

cout<<" \n\n请输入遍历的起点: ";
cin>>vd;

v=LocateVex(G,vd);//返回输入顶点的位置

cout<<"\n\n深度优先遍历: "<<endl;
DFSTraverse(G,v);

cout<<"\n\n广度优先遍历:\n";
BFSTraverse(G,v);
}