邻接表

#include 

#include

 

#define MaxVex 255

#define TRUE   1 

#define FALSE  0

 

typedef char VertexType;  //顶点类型

typedef int Bool;

Bool visited[MaxVex];  //全局数组,记录图中节点访问状态

 

typedef struct EdgeNode { //边表节点 

   int adjvex;    //该邻接点在顶点数组中的下标 

   struct EdgeNode *next;   //链域 指向下一个邻接点 

}EdgeNode;

 

typedef struct VertexNode { //头节点

   VertexType data;  //顶点信息

   EdgeNode *firstedge;  //边表头指针(指向第一条依附于该顶点的弧的指针)

}VertexNode,AdjList[MaxVex]; //顶点数组(结构体数组)  

 

typedef struct Graph{ 

   AdjList adjList; 

   int numVertexes,numEdges;  //图中当前的结点数以及边数 

}Graph,*GraphAdjList;

 

 

typedef struct LoopQueue{

   int data[MaxVex];

   int front,rear;

}LoopQueue,*Queue; //队列结构

 

void initQueue(Queue &Q){

   Q->front=Q->rear=0;

}

 

Bool QueueEmpty(Queue &Q){

   if(Q->front == Q->rear){

       return TRUE;

   }else{

       return FALSE;

    }

}

 

Bool QueueFull(Queue &Q){

   if((Q->rear+1)%MaxVex == Q->front){

       return TRUE;

   }else{

       return FALSE;

    }

}

 

void EnQueue(Queue &Q,int e){

   if(!QueueFull(Q)){

       Q->data[Q->rear] = e;

       Q->rear = (Q->rear+1)%MaxVex;

    }

}

 

void DeQueue(Queue &Q,int *e){

   if(!QueueEmpty(Q)){

       *e = Q->data[Q->front]; 

       Q->front = (Q->front+1)%MaxVex;

    }

}

 

 

void CreateALGraph(GraphAdjList &G){

   int i, j, k; 

   if(G==NULL){

       G = (GraphAdjList)malloc(sizeof(Graph));

    }

 

   printf("输入图的结点数以及边数: "); 

   scanf("%d%d",&G->numVertexes,&G->numEdges);

   fflush(stdin);

 

   printf("===========================\n");

   printf("输入各个顶点的数据:\n"); 

   for (i=0; inumVertexes; ++i){ 

       printf("顶点%d: ",i+1);

       scanf("%c", &(G->adjList[i].data)); 

       G->adjList[i].firstedge = NULL; 

       fflush(stdin); 

    }

   

   printf("===========================\n");

   for (k=0; knumEdges; ++k){

       printf("输入(vi,vj)上的顶点序号: ");

       scanf("%d%d",&i,&j);

 

       EdgeNode *ptrEdgeNode = (EdgeNode*)malloc(sizeof(EdgeNode));

       ptrEdgeNode->adjvex = j;

       ptrEdgeNode->next = G->adjList[i].firstedge;

       G->adjList[i].firstedge = ptrEdgeNode;

 

       ptrEdgeNode = (EdgeNode*)malloc(sizeof(EdgeNode));

       ptrEdgeNode->adjvex = i;

       ptrEdgeNode->next = G->adjList[j].firstedge;

       G->adjList[j].firstedge = ptrEdgeNode;

    }

}

 

void DFS(GraphAdjList &G, int i){

   visited[i] = TRUE; 

   printf("%c ", G->adjList[i].data); 

   

   EdgeNode *p = G->adjList[i].firstedge;

   while(p){

       if(!visited[p->adjvex]){

           DFS(G,p->adjvex); //递归深度遍历

       }

       p= p->next;

    }

}

 

 

void DFSTraverse(GraphAdjList &G){

   int i; 

   for (i=0; inumVertexes; ++i){

       visited[i] = FALSE;  //初始化访问数组visited的元素值为false

    }

   for (i=0; inumVertexes; ++i){

       if(!visited[i]){ //节点尚未访问

           DFS(G,i);

       }

    }

}

 

 

 

void BFSTraverse(GraphAdjList &G){ 

   int i; 

   Queue Q = (Queue)malloc(sizeof(LoopQueue)); 

 

   for (i=0; inumVertexes; ++i){ 

       visited[i] = FALSE;

    }

   initQueue(Q); 

   

   for (i=0; inumVertexes; ++i){ 

       if(!visited[i]){ 

           visited[i] = TRUE; 

           printf("%c ", G->adjList[i].data); 

           EnQueue(Q, i); 

 

           while (!QueueEmpty(Q)){ 

                DeQueue(Q, &i); 

                EdgeNode *p =G->adjList[i].firstedge; 

                while (p){ 

                    if (!visited[p->adjvex]){ 

                        visited[p->adjvex] =TRUE; 

                        printf("%c ",G->adjList[p->adjvex].data); 

                        EnQueue(Q,p->adjvex); 

                    } 

                    p = p->next; 

                }

           }

       } 

   }   

}

 

int main(){

   GraphAdjList G = NULL; 

 

   CreateALGraph(G);

 

   printf("\n图的深度优先遍历为: ");

   DFSTraverse(G);

 

   printf("\n图的广度优先遍历为: ");

   BFSTraverse(G);

 

   printf("\n");

 

   return 0;

}