用邻接表作为图的存储结构建立一个图，并对此图分别进行深度优先搜索和广度优先搜索遍历。

#include<stdio.h>

#include<stdlib.h>

#define MAX_VERTEM_NUM 10

#define INFINITY 32768

typedef enum{

        DG,DN,UDG,UDN

}graghKind;

//digraph  DG有向图

//directed network  DN有向网

//undirected graph  UDG无向图

//undirected network  UDN无向网

typedef char vertemData;

int visited[MAX_VERTEM_NUM] = {0};//访问数组

typedef struct {

        vertemData vert[MAX_VERTEM_NUM];                      //顶点向量

        int adj[MAX_VERTEM_NUM][MAX_VERTEM_NUM];       //邻接矩阵

        int vertNum,arcNum;                                                //图的顶点数和弧数

        graghKind gragh;                                                 //图的类型

}adjMatrix;

/*队列结构*/

typedef struct QNode

{

        vertemData data;

        struct QNode *next;

}QNode;

typedef struct

{

        QNode *front,*rear;  //队头队尾指针

}LinkQueue;

//求顶点位置

int locateVertem(adjMatrix *G,vertemData v){

        for(int j=0;j<G->vertNum;j++)

        {

                if(G->vert[j]==v)

                {

                        return j;

                }

        }

}

//创建无向图

int creatUDG(adjMatrix *G){

        int i,j,k,weight;

        vertemData v1,v2;

        printf("请输入图的顶点数和弧数：\n");

        scanf("%d %d",&G->vertNum,&G->arcNum);

        for(i=0;i<G->vertNum;i++)

                for(j=0;j<G->vertNum;j++)

                        G->adj[i][j] = 0;

                        printf("请输入图的顶点：\n");

        for(i=0;i<G->vertNum;i++)

        {

                getchar();

                scanf("%c",&G->vert[i]);

        }

        printf("请输入边\n");

        for(k=0;k<G->arcNum;k++){

                getchar();

                scanf("%c %c",&v1,&v2);

                i = locateVertem(G,v1);

                j = locateVertem(G,v2);

                G->adj[i][j] = 1;

                G->adj[j][i] = 1;

        }

        return 0;

}

//深度遍历无向图

void depth_first_traversal_UDG(adjMatrix *G,int *v,int n)

{

        int i;

        if(G==NULL) return;

        if(n<0||n>G->vertNum) return;

        v[n] = 1;

        if(n==0) printf("%c",G->vert[n]);

        else printf("->%c",G->vert[n]);

        for(i=0;i<G->vertNum;i++)

                if(G->adj[n][i]!=0&&v[i]!=1) depth_first_traversal_UDG(G,v,i);

}

/*创建空队列*/

int init_queue(LinkQueue *L)

{

        L->front=L->rear=(QNode*)malloc(sizeof(QNode));

        if(!L->front) return 0;

        L->front->next=NULL;

        return 0;

}

/*判断队列是否为空*/

int empty_queue(LinkQueue *L)

{

        if(L->front->next==NULL) return 1;

        else return 0;

}

/*入队列*/

int in_queue(LinkQueue *L,int n)

{

        QNode *t = (QNode*)malloc(sizeof(QNode));

        if(!t) exit(0);

        t->data = n;

        t->next = NULL;

        L->rear->next = t;

        L->rear = t;

        free(t);

        return 0;

}

/*出队列*/

int out_queue(LinkQueue *L)

{

        QNode *t;

        if(L->front==L->rear) return 0;

        t = L->front->next;

        L->front->next = t->next;

        if(t==L->rear) L->rear = L->front;

        return 1;

}

/*广度遍历*/

int BFS_traverse_UDN(adjMatrix *G)

{

        int i=0,j;

        LinkQueue *L = (LinkQueue*)malloc(sizeof(LinkQueue));

        init_queue(L);

        printf("\n广度遍历无向图：\n");

        visited[i] = 1;

        printf("%c",G->vert[i]);

        in_queue(L,i);

        do

        {

                out_queue(L);

                for(j=0;j<G->vertNum;j++)

                {

                        if(G->adj[i][j]!=0&&visited[j]!=1)

                        {

                                visited[j] = 1;

                                printf("->%c",G->vert[j]);

                                in_queue(L,j);

                        }

                }

                i++;

        }while(!empty_queue(L));

        free(L);

        return 0;

}

int main(){

        adjMatrix *G = (adjMatrix*)malloc(sizeof(adjMatrix));

        creatUDG(G);

        int visited[G->vertNum]={0};

        printf("深度优先遍历无向图：\n");

        depth_first_traversal_UDG(G,visited,0);

        BFS_traverse_UDN(G);

        return 0;

}