邻接矩阵

  1 #include<stdio.h>

  2 #include<stdlib.h>

  3 #define OK 1

  4 #define TRUE 1

  5 #define FALSE 0

  6 #define ERROR -1

  7 #define OVERFLOW -2

  8 #define MAX_VERTEX_NUM 20

  9 bool visited[MAX_VERTEX_NUM];

 10 typedef int QElemint;

 11 typedef int Status;

 12 //定义队列数据结构 

 13 typedef struct QNode

 14 {

 15     QElemint data;

 16     QNode *next;

 17 }QNode,*QueuePtr;

 18 typedef struct

 19 {

 20     QueuePtr front;

 21     QueuePtr rear;

 22 }LinkQueue;

 23 Status InitQueue(LinkQueue &Q)

 24 {

 25     Q.front=Q.rear=new QNode;

 26     if(!Q.front) exit(OVERFLOW);

 27     Q.front->next=NULL;

 28     return OK;

 29 }

 30 Status EnQueue(LinkQueue &Q,QElemint e)

 31 {

 32     QueuePtr p;

 33     p=new QNode;

 34     if(!p) exit(OVERFLOW);

 35     p->data=e;

 36     p->next=NULL;

 37     Q.rear->next=p;

 38     Q.rear=p;

 39     return OK;

 40 } 

 41 Status DeQueue(LinkQueue &Q,QElemint &e)

 42 {

 43     QueuePtr p;

 44     if(Q.front==Q.rear) return ERROR;

 45     p=Q.front->next;

 46     e=p->data;

 47     Q.front->next=p->next;

 48     if(Q.rear==p) Q.rear=Q.front;

 49     free(p);

 50     return OK;

 51 }

 52 Status QueueEmpty(LinkQueue Q)

 53 {

 54     if(Q.front==Q.rear) return TRUE;

 55     return FALSE;

 56 }

 57 //定义邻接矩阵数据结构 

 58 typedef int AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

 59 typedef struct

 60 {

 61     char vexs[MAX_VERTEX_NUM];

 62     AdjMatrix arcs;

 63     int vexnum,arcnum;

 64 }MGraph;

 65 Status CreateMGraph(MGraph &G)//构造一个图型存储结构 

 66 {

 67     int i,j,k;

 68     puts("请输入构成图的顶点个数和边数:"); 

 69     scanf("%d%d%*c",&G.vexnum,&G.arcnum);

 70     puts("请输入顶点数值:"); 

 71     for(i=0;i<G.vexnum;i++)

 72        scanf("%c",&G.vexs[i]);

 73     for(i=0;i<G.vexnum;i++)

 74         for(j=0;j<G.vexnum;j++)

 75            G.arcs[i][j]=0;

 76     puts("请依次输入边(Vi,Vj)的顶点序号:");

 77     for(k=0;k<G.arcnum;++k)

 78     {

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

 80         G.arcs[i][j]=1;

 81         G.arcs[j][i]=G.arcs[i][j];

 82     }

 83     return OK;

 84 }

 85 int FirstAdjVex(MGraph G,int v)

 86 {

 87     int i;

 88     for(i=0;i<G.vexnum;i++)

 89         if(G.arcs[v][i]==1) return i;

 90         return ERROR;

 91 }

 92 int NextAdjVex(MGraph G,int v,int w)

 93 {

 94     for(int i=w+1;i<G.vexnum;i++)

 95     if(G.arcs[v][i]==1)  return i;

 96     return ERROR; 

 97 } 

 98 void DFS(MGraph G,int v)

 99 {

100     int w;

101     printf("%c ",G.vexs[v]);

102     visited[v]=TRUE;

103     for(w=FirstAdjVex(G,v);w>=0;w=NextAdjVex(G,v,w))

104        if(!visited[w]) DFS(G,w);

105 }

106 Status DFSTraverse(MGraph G)  //深度优先搜索

107 {

108     int v;

109     for(v=0;v<G.vexnum;++v)

110         visited[v]=FALSE;

111     for(v=0;v<G.vexnum;++v)

112        if(!visited[v]) 

113             DFS(G,v);

114     return OK;

115 }    

116 Status BFSTraverse(MGraph G)//广度优先搜索

117 {

118     int u,v,w;

119     LinkQueue Q;

120     for(v=0;v<G.vexnum;++v)

121        visited[v]=FALSE;

122     InitQueue(Q);

123     for(v=0;v<G.vexnum;++v)

124        if(!visited[v])

125        {

126             visited[v]=TRUE;

127             printf("%c ",G.vexs[v]); 

128             EnQueue(Q,v);

129             while(!QueueEmpty(Q))

130             {

131                 DeQueue(Q,u);

132                 for(w=FirstAdjVex(G,u);w>=0;w=NextAdjVex(G,u,w))

133                    if(!visited[w])

134                    {

135                         visited[w]=TRUE;

136                         printf("%c ",G.vexs[w]); 

137                         EnQueue(Q,w);

138                    }

139             }

140         }

141         return OK;

142 }

143 Status main()

144 {

145     MGraph G;

146     CreateMGraph(G);   //构造一个图型存储结构 

147     puts("邻接矩阵的深度优先遍历为:");

148     DFSTraverse(G); //深度优先搜索

149     puts("\n邻接矩阵的广度优先遍历为:");

150     BFSTraverse(G); //广度优先搜索 

151     putchar('\n');      

152     system("pause");

153     return OK; 

154 }