#include <stdio.h>
#include <stdlib.h>
#define MAX 30
#define N 30
#define M 10
#define NULL 0
typedef struct ebox
{
    int ivex,jvex; //该边依附两个顶点的位置
    struct ebox *ilink,*jlink;//分别指向依附这两个顶点的下一条边
}ebox,*pebox;
typedef struct vexbox
{
    char *data;
    pebox firstedge;//指向第一条依附该顶点的边
}vexbox,*pvexbox;
typedef struct amlgraph//邻接多重表
{
    vexbox adjmulist[MAX];
}amlgraph,pamlgraph;
typedef struct QNode//链式队列
{
    int data;
    struct QNode*next;
}QNode,*QueuePtr;
typedef struct
{
    QueuePtr front;//队头指针
    QueuePtr rear;//队尾指针
}LinkQueue;
LinkQueue InitQueue()//构造一个空队列Q
{
    LinkQueue Q;
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
    Q.front->next=NULL;
    return Q;
}
int DeQueue(LinkQueue*Q)//队列不为空时，删除队头元素
{
    QueuePtr p;
    int e;
    p=Q->front->next;
    e=p->data;
    Q->front->next=p->next;
    if(Q->rear==p)
    Q->rear=Q->front;
    free(p);
    return e;
}
void EnQueue(LinkQueue*Q,int e)//插入e为新的队尾元素
{
    QueuePtr p;
    p=(QueuePtr)malloc(sizeof(QNode));
    p->data=e;
    p->next=NULL;
    Q->rear->next=p;
    Q->rear=p;
}
int QueueEmpty(LinkQueue Q)//判定队列是否为空
{
    if(Q.front==Q.rear)
    return     1;
    else return 0;
}
int visited[MAX]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
void initgraph(amlgraph &G,int n)//？
{
    for(int i=0;i<n;i++)
        G.adjmulist[i].firstedge=NULL;
}
void SCANF(char name[N][M],int n,amlgraph &G)
{
    int i;
    printf("请输入结点名称：\n");
    for(i=0;i<n;i++)
    {
        scanf("%s",name[i]);
        G.adjmulist[i].data=name[i];
    }
}
void CreateGraph(int n,amlgraph &G)//构造邻接多重表
{
    pebox p1,p2;
    int i,j,k,m;
    int mark;
    initgraph(G,n);
    printf("请输入边的数量:");
    scanf("%d",&m);
    for(k=0;k<m;k++)
    {
        printf("请输入第%d条边的两个顶点:",k+1);
        scanf("%d%d",&i,&j);
        p1=(pebox)malloc(sizeof(ebox));
        p1->ivex=i;
        p1->jvex=j;
        p1->ilink=NULL;
        p1->jlink=NULL;
        p2=G.adjmulist[i].firstedge;
        if(p2==NULL)
            G.adjmulist[i].firstedge=p1;
        else
        {
            mark=0;
            while(mark==0)
            {
                if(p2->ivex==i && p2->ilink==NULL) mark=1;
                else if(p2->jvex==i && p2->jlink==NULL) mark=2;
                else if(p2->ivex==i) p2=p2->ilink;
                else p2=p2->jlink;
            }
            if(mark==1) p2->ilink=p1;
            else p2->jlink=p1;
        }
        p2=G.adjmulist[j].firstedge;
        if(p2==NULL)
            G.adjmulist[j].firstedge=p1;
        else
        {
            mark=0;
            while(mark==0)
            {
                if(p2->ivex==j && p2->ilink==NULL) mark=1;
                else if(p2->jvex==j && p2->jlink==NULL) mark=2;
                else if(p2->ivex==j) p2=p2->ilink;
                else p2=p2->jlink;
            }
            if(mark==1) p2->ilink=p1;
            else p2->jlink=p1;
        }
    }
}
void visit(amlgraph G,int v)
{
    printf("\n%s",G.adjmulist[v].data);
    visited[v]=1;
}
void DFS(amlgraph G,int v)
{
    pebox p;
    int mark;
    if(visited[v]==0) visit(G,v);
    else return;
    p=G.adjmulist[v].firstedge;
    if(p==NULL)
        return;
    else
    {
        mark=0;
        while(mark==0)
        {
            if(p->ivex==v)
            {
                if(visited[p->jvex]==0)
                {
                    printf("\t\t\t<%d,%d>",p->ivex,p->jvex);
                    DFS(G,p->jvex);
                }
                if(p->ilink==NULL) mark=1;
                else p=p->ilink;
            }
            else
            {
                if(visited[p->ivex]==0)
                {
                    printf("\t\t\t<%d,%d>",p->jvex,p->ivex);
                    DFS(G,p->ivex);
                }
                if(p->jlink==NULL) mark=1;
                else p=p->jlink;
            }
        }
    }
}
void BFS(amlgraph G,int v)
{
    LinkQueue Q;
    pebox p;
    int e;
    int mark;
    Q=InitQueue();
    if(visited[v]==0) visit(G,v);
    else return;
    EnQueue(&Q,v);
    while(QueueEmpty(Q)!=1)
    {
        e=DeQueue(&Q);
        p=G.adjmulist[e].firstedge;
        if(p==NULL) return;
        mark=0;
        while(mark==0)
        {
            if(p->ivex==e)
            {
                if(visited[p->jvex]==0)
                {
                    EnQueue(&Q,p->jvex);
                    printf("\t\t\t<%d,%d>",p->ivex,p->jvex);
                    visit(G,p->jvex);
                }
                if(p->ilink==NULL) mark=1;
                else p=p->ilink;
            }
            else
            {
                if(visited[p->ivex]==0)
                {
                    EnQueue(&Q,p->ivex);
                    printf("\t\t\t<%d,%d>",p->jvex,p->ivex);
                    visit(G,p->ivex);
                }
                if(p->jlink==NULL) mark=1;
                else p=p->jlink;
            }
        }
    }
}
void clear(int v[MAX])
{
    int i;
    for(i=0;i<MAX;i++)
    v[i]=0;
}
void main()
{
    int n,v,i;
    char name[N][M];
    amlgraph G;
    printf("请输入结点的数量:");
    scanf("%d",&n);
    SCANF(name,n,G);
    CreateGraph(n,G);
    printf("请输入从哪一个结点开始访问:");
    scanf("%d",&v);
    printf("该图的深度优先遍历和所经过的边为:");
    for(i=-1;i<n;i++)
    {
        if(i==-1) DFS(G,v);
        else DFS(G,i);
    }
    clear(visited);
    printf("\n该图的广度优先遍历和所经过的边为:");
    for(i=-1;i<n;i++)
    {
        if(i=-1) BFS(G,v);
        else BFS(G,i);
    }
    printf("\n两种遍历结束!\n");
}存储与遍历

看看.

正在学习数据结构呢！

图：

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

#define MAX_VEXTEX_NUM 9 /* 图中顶点数 */
#define ARC_NUM 12       /* 图中弧数 */
#define MAX_QUEUEMEM (MAX_VEXTEX_NUM+1)

/* 定义描述图的顶点之间连接信息的数组 */
int GraphEdge[ARC_NUM * 2][2] = {{0,1},{1,0},{1,2},{2,1},{2,3},{3,2},{3,4},{4,3},{4,5},{5,4},{5,0},{0,5},{0,6},{6,0},{6,8},{8,6},{6,7},{7,6},{7,8},{8,7},{7,3},{3,7},{8,4},{4,8}};
/*定义数组visited用来标示一个顶点是否被访问过*/
int visited[MAX_VEXTEX_NUM]={0,0,0,0,0,0,0,0,0};
/*定义表结点，即每条弧对应的结点 */
typedef struct ArcNode{
  int adjvex;                 /* 该弧所指向的顶点的位置 */
  struct ArcNode * nextarc;   /* 指向下一条弧的指针 */
}ArcNode;

/* 定义头结点 */
typedef struct VNode{
  int data;                    /* 顶点信息 */
  struct ArcNode * firstarc;   /* 指向第一条依附该顶点的弧的指针 */
}VNode,AdjList[MAX_VEXTEX_NUM]; 

/* 定义图的结构 */
typedef struct {
    VNode vertices[MAX_VEXTEX_NUM];/* 定义表头数组 */
    int vexnum;      /* 定义图中顶点数 */
    int arcnum;      /* 定义图中弧数 */
}ALGraph;

/*建立一个使用邻接表存储的图*/
void CreateGraph(ALGraph * alGraph)
{
    int i,j;
    ArcNode * newnode;
    ArcNode * vexNode;
    alGraph->vexnum = MAX_VEXTEX_NUM;
    alGraph->arcnum = ARC_NUM;
    /* 初始化表头 */
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        alGraph->vertices[i].data = i;
        alGraph->vertices[i].firstarc = NULL;   
    }
    for(j=0;j<2*ARC_NUM;j++)
    {
        i = GraphEdge[j][0];
        if(alGraph->vertices[i].firstarc==NULL)
        {
          newnode = ( ArcNode * ) malloc (sizeof(ArcNode));
          newnode->adjvex = GraphEdge[j][1];
          newnode->nextarc = NULL;
          alGraph->vertices[i].firstarc = newnode;
        }
        else
        {
          vexNode = alGraph->vertices[i].firstarc;
          while(vexNode->nextarc != NULL)
          {
            vexNode = vexNode->nextarc;
          }
          newnode = ( ArcNode * ) malloc (sizeof(ArcNode));
          newnode->adjvex = GraphEdge[j][1];
          newnode->nextarc = NULL;
          vexNode->nextarc = newnode;
        }
    }
}
/* 打印这个图 */
void OutputGraph(ALGraph * alGraph)
{
    int i;
    ArcNode * vexNode;
    printf("The graph dedicated by adjacency list is:\n");
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        printf("the header is: [%d]  -> ",alGraph->vertices[i].data);
        vexNode = alGraph->vertices[i].firstarc;
        while(vexNode != NULL)
        {
          printf("[%d] -> ",vexNode->adjvex);
          vexNode=vexNode->nextarc;
        }
        printf("[END]\n");
    }
}
/*递归实现DFS*/
void DFS(ALGraph * alGraph,int v)
{
    int w;
    ArcNode * vexNode;
    visited[v] = 1;
    printf("[%d] -> ",v);
    vexNode = alGraph->vertices[v].firstarc;
    while(vexNode != NULL)
    {
        w = vexNode->adjvex;
        if(visited[w]==0)
          DFS(alGraph,w);
        vexNode = vexNode->nextarc;
    }
}
/* 图的深度优先遍历 */
void DFSTraverse(ALGraph * alGraph)
{
    int i;
    /*访问标志数组初始化*/
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        visited[i] = 0;
    }
    printf("\n");
    puts("********************************************");
    puts("*  the function DFSTraverse will traverse  *");
    puts("*     the graphby Depth First Search       *");
    puts("********************************************");
    puts("the result of DFS is:");
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        if(visited[i] == 0)
          DFS(alGraph,i);
    }
    printf("[end]\n");
}
/*为了实现广度优先遍历，需要借助一个队列 */
typedef struct{
  int queuemem[MAX_QUEUEMEM];
  int header;
  int rear;
}QUEUE;
void InitQueue(QUEUE *queue)
{
    queue->header = 0;
    queue->rear = 0;
}
void EnQueue(QUEUE *queue,int v)
{
    queue->queuemem[queue->rear] = v;
    queue->rear++;
}
int DelQueue(QUEUE *queue)
{
    return queue->queuemem[queue->header++];
}
int EmptyQueue(QUEUE *queue)
{
   if(queue->header == queue->rear)
     return 1;
   return 0;
}
/* 广度优先遍历 */
void BFSTraverse(ALGraph * alGraph)
{
    int i;
    int w;
    ArcNode * vexNode;
    QUEUE queue;
    InitQueue(&queue);
    /*访问标志数组初始化*/
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        visited[i] = 0;
    }
    printf("\n");
    puts("********************************************");
    puts("*  the function BFSTraverse will traverse  *");
    puts("*     the graph by Breadth First Search    *");
    puts("********************************************");
    puts("the result of BFS is:");
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        if(visited[i] == 0)
        {
            visited[i] = 1;
            printf("[%d] -> ",i);
            EnQueue(&queue,i);
            while(!EmptyQueue(&queue))
            {
              w = DelQueue(&queue);
              vexNode = alGraph->vertices[w].firstarc;
              while(vexNode != NULL)
              {
                w = vexNode->adjvex;
                if(visited[w]==0)
                {
                  visited[w] = 1;
                  printf("[%d] -> ",w);
                  EnQueue(&queue,w);
                }
                vexNode = vexNode->nextarc;
              }
            }
        }
    }
    printf("[end]\n");
   
}
int main()
{
    /*定义图结点*/
    ALGraph alGraph;
   
    clrscr();
    /*建立图的邻接表*/
    CreateGraph(&alGraph);
    /*输出图的邻接表*/
    OutputGraph(&alGraph);
    /*深度优先遍历*/
    DFSTraverse(&alGraph);
    /*广度优先遍历*/
    BFSTraverse(&alGraph);
    getch();
    return 0;
}

好强！

亲 能不能再给看看 修改一下让他能顺利运行啊

把最后的“存储与遍历”去掉，能运行