图的存储方式和遍历

图的邻接矩阵

#include<stdio.h>
#include<queue>
#include<math.h>
#include<iostream>
using namespace std;

#define INF 1000000
#define Max 100

int vis[Max];

//邻接矩阵存储
typedef char VertexType;
typedef int EdgeType;
typedef struct
{
    VertexType  Vexs[Max];        // 顶点向量
    EdgeType    Edges[Max][Max];  // 边
    int vexnum,arcnum;            //图的当前顶点数和弧数
}Graph;


//获取v在图G中的位置
int Locatevex(Graph &G,char v)    
{ 
  int i;
  for(i=0;G.Vexs[i]!=v;i++)
      if(i>G.vexnum)
          printf("ERROR");
 return i;
}

//建立图
void Create(Graph &G)   
{

  int i,j,k;
  char v1,v2;
  cout<<"输入图的顶点数和弧数:";
  cin>>G.vexnum>>G.arcnum;
  for(i=0;i<G.vexnum;i++)
   {
       cout<<"输入图的一个顶点（字符）：";
       cin>>G.Vexs[i];
   }

  for(i=0;i<G.vexnum;i++)
     for(j=0;j<G.vexnum;j++)
         G.Edges[i][j]=0;

  for(k=0;k<G.arcnum;k++)
  {
    cout<<"输入一条边连接的两个顶点：";
    cin>>v1>>v2;
    i=Locatevex(G,v1);
    j=Locatevex(G,v2);
    G.Edges[i][j]=G.Edges[j][i]=1;
  }
}

//位置
int AdjVes(Graph &G,int k)  
{
  int i;
  for(i=0;i<G.vexnum;i++)
    if(G.Edges[k][i]&&!vis[i])
        return i;
    return -1;
}

//邻接矩阵表示的图的递归深度优先遍历
void DFS(Graph &G,int k)  //从第k个顶点出发递归深度优先遍历
{
    int i;
    vis[k]=1;
    cout<<G.Vexs[k];
    for(i=AdjVes(G,k);i>=0;i=AdjVes(G,i))
        if(!vis[i])
         DFS(G,i);
}

//邻接矩阵表示的图的广度优先遍历
void BFS(Graph &G)
{
    int i,j,u;
    queue<int>Q;
    for(i=0;i<G.vexnum;i++)
        vis[i]=0;
    for(i=0;i<G.vexnum;i++)
        if(!vis[i])
        {
            vis[i]=1;
            cout<<G.Vexs[i];
            Q.push(i);
            while(!Q.empty())
            {
              u=Q.front();
              Q.pop();
              for(j=AdjVes(G,u);j>=0;j=AdjVes(G,u))
                  if(!vis[j])
                  {
                      vis[j]=1;
                      cout<<G.Vexs[j];
                      Q.push(j);
                  }
            }
        }
}

int main ()
{
  int i;
  Graph G;
  Create(G);

  cout<<"邻接矩阵深度优先遍历：";
  for(i=0;i<G.vexnum;i++)
    vis[i]=0;
  for(i=0;i<G.vexnum;i++)
    if(!vis[i])
     DFS(G,i);
  cout<<endl;

  cout<<"邻接矩阵广度优先遍历：";
  BFS(G);
  cout<<endl;
  return 0;
}

图的邻接表

#include<stdio.h>
#include<malloc.h>
#include<queue>
#include<iostream>
using namespace std;

#define INF 1000000
#define Max 100

int vis[Max];  // 标记数组

//邻接表存储
typedef struct ArcNode
{
   int adjvex;                // 该弧所指向的顶点的位置
   struct ArcNode *nextarc;   // 指向下一条弧的指针
}ArcNode;
typedef struct VNode
{
   char data;                // 顶点信息
   ArcNode *firstarc;        // 指向第一条依附该顶点的弧的指针
}VNode, AdjList[Max];
typedef struct
{
   AdjList vertices;
   int vexnum,arcnum;       // 图当前顶点数和弧数
}Graph;

//获取v在图G中的位置
int Locatevex(Graph &G,char v)
{
  int i;
  for(i=0;G.vertices[i].data!=v;i++)
      if(i>G.vexnum)
          cout<<"ERROR"<<endl;
 return i;
}

//建立图
void Create(Graph &G)
{
  int i,j,k;
  char v1,v2;
  ArcNode *p,*q;
  cout<<"输入图的顶点数和弧数:";
  cin>>G.vexnum>>G.arcnum;
  for(i=0;i<G.vexnum;i++)
  {
      cout<<"输入图的一个顶点（字符）：";
      cin>>G.vertices[i].data;
      G.vertices[i].firstarc=NULL;
  }
  for(k=0;k<G.arcnum;k++)
  {
    cout<<"输入一条边连接的两个顶点：";
    cin>>v1>>v2;
    i=Locatevex(G,v1);
    j=Locatevex(G,v2);

    p=(ArcNode *)malloc(sizeof(ArcNode));
    p->adjvex=i;                       // 确认顶点位置
    p->nextarc=G.vertices[j].firstarc; // 指向下一条弧的指针
    G.vertices[j].firstarc=p;          //赋值

    q=(ArcNode *)malloc(sizeof(ArcNode));
    q->adjvex=j;
    q->nextarc=G.vertices[i].firstarc;
    G.vertices[i].firstarc=q;
  }
}

//位置
int AdjVes(Graph &G,int k)
{
    ArcNode *p;
    for(p=G.vertices[k].firstarc;p!=NULL;p=p->nextarc)
        if(!vis[p->adjvex])
            return p->adjvex;
    return -1;
}

//邻接表表示的图的递归深度优先遍历
void DFS(Graph &G,int k)   //从第k个顶点出发递归深度优先遍历
{
  int i;
  vis[k]=1;
  cout<<G.vertices[k].data;
  for(i=AdjVes(G,k);i>=0;i=AdjVes(G,i))
        if(!vis[i])
           DFS(G,i);
}

//邻接表表示的图的递归广度优先遍历
void BFS(Graph &G)
{
    int i,j,u;
    queue<int>Q;
    for(i=0;i<G.vexnum;i++)  vis[i]=0;
    for(i=0;i<G.vexnum;i++)
        if(!vis[i])
        {
            vis[i]=1;
            cout<<G.vertices[i].data;
            Q.push(i);
            while(!Q.empty())
            {
              u=Q.front();
              Q.pop();
              for(j=AdjVes(G,u);j>=0;j=AdjVes(G,u))
                  if(!vis[j])
                  {
                      vis[j]=1;
                      cout<<G.vertices[j].data;
                      Q.push(j);
                  }
            }
        }
}

int main ()
{
  int i;
  Graph G;
  Create(G);

  cout<<"邻接表深度优先遍历：";
  for(i=0;i<G.vexnum;i++)
    vis[i]=0;
  for(i=0;i<G.vexnum;i++)
    if(!vis[i])
     DFS(G,i);
  cout<<endl;

  cout<<"邻接表广度优先遍历：";
  BFS(G);
  cout<<endl;
  return 0;
}