DFS的核心思想在於對訪問的鄰接節點進行遞迴呼叫；BFS的核心思想在於建立了一個鄰接節點的佇列。

在Dev C++中除錯執行通過。

用下圖進行了測試。

#include <stdio.h>  
#define MaxVertexNum 50  
#define QueueSize 50  

typedef enum{FALSE,TRUE}shifou;  
shifou visited[MaxVertexNum];                                                     

typedef char VertexType;   //頂點是字元型
typedef int EdgeType;   //邊是整型

typedef struct    //圖的鄰接矩陣儲存結構
{  

    VertexType vexs[MaxVertexNum];  //頂點向量  

    EdgeType edges[MaxVertexNum][MaxVertexNum];     //鄰接矩陣  

    int vexnum,arcnum;    //圖中當前的頂點數和邊數  

}MGraph;  

/* 鄰接矩陣的建立*/ 

void CreateGraph(MGraph *G)  
{   
    int i,j,k;  
    char ch1,ch2;  

    printf("請輸入頂點數和邊數(輸入格式為:頂點數,邊數):");  

    scanf("%d,%d",&(G->vexnum),&(G->arcnum));  

    printf("請輸入頂點名稱(輸入格式為:a,b,c...)：");  

    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->edges[i][j]=0;  

        printf("請輸入每條邊對應的兩個頂點名稱(輸入格式為:a,b):\n");  

        for(k=0;k<G->arcnum;k++)  
        {  
            getchar();  
            printf("請輸入第%d條邊的兩個頂點名稱：",k+1);  
            scanf("%c,%c",&ch1,&ch2);  
            for(i=0;ch1!=G->vexs[i];i++);  
            for(j=0;ch2!=G->vexs[j];j++);  
    G->edges[j][i]=1;
            G->edges[i][j]=1;  
        }  
}  

/* 深度優先遍歷 */ 

void Depth(MGraph *G,int i)  
{  
    int j;  

    printf("%c\n",G->vexs[i]);   //訪問頂點vi  

    visited[i]=TRUE;          

    for(j=0;j<G->vexnum;j++)           //依次搜尋vi鄰接點  
        if(G->edges[i][j]==1 && !visited[j])  
            Depth(G,j);  
}  

void Depthsearch(MGraph *G)  
{  

    int i;  

    for(i=0;i<G->vexnum;i++)  
        visited[i]=FALSE;     

    for(i=0;i<G->vexnum;i++)  
        if(!visited[i])   
            Depth(G,i);  
}  

/*廣度優先遍歷*/ 

typedef struct 
{  
    int front;  
    int rear;  
    int count;  
    int data[QueueSize];  
}AQueue;   

void InitQueue(AQueue *Q)  
{  
    Q->front=Q->rear=0;  
    Q->count=0;  
}  

int QueueEmpty(AQueue *Q)  
{  
    return Q->count!=QueueSize;  

}  

int QueueFull(AQueue *Q)  
{  
    return Q->count==QueueSize;  
}  

void EnQueue(AQueue *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(AQueue *Q)  
{  
    int temp;  
    if(QueueEmpty(Q))  
    {   
        printf("Queue underflow");  
        return 0;  
    }  
    else 
    {  
        temp=Q->data[Q->front];  
        Q->count--;  
        Q->front=(Q->front+1)%QueueSize;  
        return temp;  
    }  
}  

void Breadth(MGraph *G,int k)  
{   
    int i,j;  
    AQueue 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->edges[i][j]==1&&!visited[j])  
            {  
                printf("%c\n",G->vexs[j]);  
                visited[j]=TRUE;  
                EnQueue(&Q,j);  
            }  
    }  
}  

void Breadthsearch(MGraph *G)  
{  
    int i;  
    for (i=0;i<G->vexnum;i++)  
        visited[i]=FALSE;  
    for (i=0;i<G->vexnum;i++)  
        if (!visited[i])   
            Breadth(G,i);  
}  

void main()  
{  
    MGraph G;  
    CreateGraph(&G);
    printf("深度優先搜尋結果為：");
    printf("\n");  
    Depthsearch(&G); 
    printf("廣度優先搜尋結果為：");
    printf("\n");  
    Breadthsearch(&G);  
}