图还未完成

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<iostream.h>


#define  OK 1
#define ERROR 0
#define OVERFLOW -2
#define MaxInt 32767
#define MVNum 100
#define QueueSize 30
bool visited[MVNum];
typedef int status;
typedef char VerTexType;//假设定点的类型为整型
typedef int ArcType;//假设边的权值为整型


/*******************************************/
/*图的邻接矩阵表示                        */
/*****************************************/
typedef struct
{
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum];//邻接矩阵
int vexnum,arcnum;
}AMGraph;


/*******************************************/
/*确定v在G中的位置                        */
/*****************************************/


int LocateVex(AMGraph &G, VerTexType v)
{
int j=ERROR,k;
for( k=0; k<G.vexnum; ++k)
{
if(G.vexs[k]=v)
{
j=k;
break;
}
}
return(j);
}




/*****************************************/
/*采用邻接矩阵表示法，创建无向网G       */
/***************************************/
status CreateUDN(AMGraph &G)
{
int i,j,k;
VerTexType v1,v2;
cin>>G.vexnum>>G.arcnum;
for(i=0; i<G.vexnum; ++i)
cin>>G.vexs[i];
for(i=0; i<G.vexnum; ++i)
for(j=0; j<G.vexnum; ++j)
G.arcs[i][j] = MaxInt;
for(k=0; k<G.arcnum; ++k)
{
cin>>v1>>v2;
i = LocateVex(G,v1);
j = LocateVex(G,v2);
G.arcs[i][j] = 1;

}
return OK;
}






//深度优先搜索遍历


void DFS_AM(AMGraph G, int v)
{
int w;
cout<<v;visited[v]=true;
for(w=0;w<G.vexnum;w++)
if((G.arcs[v][w]!=0)&&(!visited[w])) DFS_AM(G,w);
}




void DFSTraverse(AMGraph G)
{
int v;
for(v=0; v<G.vexnum; ++v) visited[v] = false;
for(v=0; v<G.vexnum; ++v)
if(!visited[v]) DFS_AM(G,v);
}


/************************************************************************/  
/* 广度优先遍历（广度优先搜索）                                         */  
/************************************************************************/  
typedef struct  
{  
    int front;  
    int rear;  
    int count;  
    int data[QueueSize];  
}CirQueue;  
void InitQueue(CirQueue *Q)  //创建队列
{  
    Q->front=Q->rear=0;  
    Q->count=0;  
}  
int QueueEmpty(CirQueue *Q)//判断队列是否为空  
{  
    return Q->count=QueueSize;  
}  
int QueueFull(CirQueue *Q)  
{  
    return Q->count==QueueSize;  
}  
void EnQueue(CirQueue *Q,int x)  //插入
{   
    if (QueueFull(Q))  
        printf("Queue overflow");  
    else  
    {   
        Q->count++;  
        Q->data[Q->rear]=x;  
        Q->rear=(Q->rear+1)%QueueSize;  
    }  
}  
int DeQueue(CirQueue *Q)  //删除
{  
    int temp;  
    if(QueueEmpty(Q))  
    {   
        printf("Queue underflow");  
        return NULL;  
    }  
    else  
    {  
        temp=Q->data[Q->front];  
        Q->count--;  
        Q->front=(Q->front+1)%QueueSize;  
        return temp;  
    }  
}  
void BFSM(AMGraph *G,int k)  
{   
    int i,j;  
    CirQueue Q;  
    InitQueue(&Q);  
    printf("广度优先遍历结点: 结点%c /n",G->vexs[k]);  
    visited[k]=true;  
    EnQueue(&Q,k);  
    while (!QueueEmpty(&Q))  
    {  
        i=DeQueue(&Q);  
        for (j=0;j<G->vexnum;j++)  
            if(G->arcs[i][j]==1&&!visited[j])  
            {  
                printf("广度优先遍历结点:%c/n",G->vexs[j]);  
                visited[j]=true;  
                EnQueue(&Q,j);  
            }  
    }  
}  
void BFSTraverseM(AMGraph *G)  
{  
    int i;  
    for (i=0;i<G->vexnum;i++)  
        visited[i]=false;  
    for (i=0;i<G->vexnum;i++)  
        if (!visited[i])   
            BFSM(G,i);  
}  


int main()
{
AMGraph A;
CreateUDN(A);
DFSTraverse(A);
BFSTraverseM(&A);
return 0;
}