作了一个小程序，图的建立，邻接矩阵表示，然后先深和先广搜索，但是，搜索的结果都有些错误，但是调试了好久都没有找到.....大家帮忙看看....


#include <stdio.h>
#include<iostream>
#define Error printf
#define QueueSize 30


typedef enum {FALSE ,TRUE}Boolen;
int dfn[50];//顶点先身编号的数组
Boolen visited[50];//标记已访问的数组



//**********************************//
//邻接矩阵的数据类型
using namespace std;
typedef char Vertexdata; //顶点数据类型
typedef int Edgedata ;//边上的权值
struct Graph{
    char vexlist [10];//顶点的集合
    int edge[50][50];//邻接矩阵边表
    int n,e;//顶点数和边数
};


typedef struct
{ int front;
int rear;
int count;
int data[QueueSize];
}CirQueue;//队列的结构


//*************************************//

//*************************************//

//图的邻接矩阵表示
void creatmgraph(Graph* G)//建立无向图的 邻接矩阵表示
{
    
    int i,j,k,w,x,y;
    puts("请输入顶点数和边的数目.\n");
    //    scanf("%d %d",&(G->n),&(G->e));
    cin >> G->n>>G->e;
    puts("请输入顶点信息!\n");
    for (i=0;i<G->n;i++)
        G->vexlist[i]=getchar();//录入顶点信息
    for (i=0;i<G->n;i++)
        for (j=0;j<G->n;j++)
            G->edge[i][j]=0;//邻接矩阵初始化
        puts("请输入边两顶点，然后输入边的权值!\n");
        for (k=0;k<G->e;k++)
        {
            scanf("%d %d %d",&i,&j,&w);
            G->edge[i][j]=w;
            G->edge[j][i]=w;
        }//读入边建立矩阵
        puts("该图的邻接矩阵为：\n");
        for (x=0;x<G->n;x++)
        {
            for(y=0;y<G->n;y++)
                printf("%d",G->edge[x][y]);
            printf("\n");
        }
        
}


//****************************************

/*先深搜索邻接矩阵*/
void DFS2(Graph* G,int i)
{    
    int j=0;
    
    //    puts("先深搜索矩阵为：\n");
    printf("%d\n",G->vexlist[i]) ;
    visited[j]=TRUE;
    //dfn[i]=count;
    //count++;
    for(j=0;j<G->n;j++)
    {
        if((G->edge[i][j]==1)&&!visited[j])
            DFS2(G,j);
    }
    
    
}


void DFSTraverse(Graph* G)
{
    //    int count=1;
    int i=0;
    for(int j=0;j<G->n;j++)
        visited[j]=FALSE;
    for(int k=0;k<G->n;k++)
        if(!visited[k])
            DFS2(G,i);
}//矩阵的先深搜索的初始化



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))
        Error("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))
    { 
        Error("Queue underflow");
        return NULL;
    }
    else{
        temp=Q->data[Q->front];
        Q->count--;
        Q->front=(Q->front+1)%QueueSize;
        return temp;
    }
}//删除队列中元素




//邻接矩阵的先广遍历
void BFSM(Graph *G,int k)
{ 
    
    int i,j;
    CirQueue Q;
    InitQueue(&Q);
    printf("%c\n",G->vexlist[k]);
    visited[k]=TRUE;
    EnQueue(&Q,k);
    while (!QueueEmpty(&Q))
    { 
        i=DeQueue(&Q);
        for (j=0;j<G->n;j++)
            if(G->edge[i][j]==1&&!visited[j])
            {   
                printf("%c\n",G->vexlist[j]);
                visited[j]=TRUE;
                EnQueue(&Q,j);
            }
    }
}
//先广搜索

void BFSTraverseM(Graph *G)
{
    
    int i;
    for (i=0;i<G->n;i++)
        visited[i]=FALSE;
    for (i=0;i<G->n;i++)
        if (!visited[i]) 
            BFSM(G,i);
}//先广搜索初始化

int main(void)
{   
    int i=0;
    int j=0;
    puts("邻接矩阵表示\n");
    Graph* G;
    G=new Graph;
    creatmgraph( G);//创建图的邻接矩阵
    puts("先深搜索矩阵为：\n");
    DFSTraverse( G);//先深遍历图的矩阵
    printf("\t\t广度优先遍历结点: 结点\n");
    BFSTraverseM(G);//先广搜索
    
    return 0;
    
}