数据结构1800关于图的代码精选（一）

考研数据结构

图的代码汇总（一）

结构体

//邻接矩阵
typedef struct 
{
  int Vex[Max];
  int Edge[Max][Max];
  int vexnum,arcnum;
}MGraph;

//邻接表
typedef struct ArcNode
{
  int adjvex;
  ArcNode *next;
}ArcNode;
typedef struct VNode
{
  int data;
  ArcNode *first;
}VNode,AdjList[Max];
typedef struct 
{
  AdjList vertices;
  int vexnum,arcnum;
}ALGraph;

一、设无向图G有n个顶点和m条边，试编写用邻接表存储该图的算法

void creat(ALGraph g){
  int m,n;
  scanf("%d%d",&m,&n);
  for(int i=0;i<n;i++){
    scanf("%d",&g.vertices[i].data);
    g.vertices[i].first=NULL;
  }
  for(int k=0;k<m;k++){
    int v1,v2;
    scanf("%d%d",&v1,&v2);
    ArcNode p;
    p->adjvex=v2;
    p->next=g.vertices[v1].first;
    g.vertices[v1].first=p;
    p->adjvex=v1;
    p->next=g.vertices[v2].first;
    g.vertices[v2].first=p;
  }
}

二、设有向图G有n个顶点和e条边，写一算法，根据G的邻接表生成G的反向连接表

void reverse(ALGraph gin,ALGraph gout){
  for(int i=0;i<gin.vexnum;i++){
    gout.vertices[i].data=gin.vertices[i].data;
    gout.vertices[i].first=NULL;
  }
  ArcNode p;
  for(int i=0;i<gin.vexnum;i++){
    p=gin.vertices[i].first;
    while(p){
      int j=p->adjvex;
      ArcNode s=malloc(sizeof(ArcNode));
      s->adjvex=i;
      s->next=gout.vertices[j].first;
      gout.vertices[j].first=s;
      p=p->next;
    }
  }
  
}

三、写出从图的邻接表表示转换成邻接矩阵的表示算法

void ALtoM(ALGraph g,MGraph G){
  for(int i=0;i<g.vexnum;i++){
    for(int j=0;j<g.vexnum;j++){
      G.Edge[i][j]=0;
    }
  }
  for(int i=0;i<g.vexnum;i++){
    ArcNode p=g.vertices[i].first;
    while(p){
      int j=p->adjvex;
      G.Edge[i][j]=1;
      p=p->next;
    }
  }
}

四、写出从图的邻接矩阵表示转换成邻接表的表示算法

void MtoAL(MGraph G,ALGraph g){
  for(int i=0;i<g.vexnum;i++){
    for(int j=0;j<g.vexnum;j++){
      if(G.Edge[i][j]!=0){
        ArcNode p=malloc(sizeof(ArcNode));
        p->adjvex=j;
        p->next=g.vertices[i].first;
        g.vertices[i].first=p;
      }
    }
  }
}

五、已知某有向图的邻接表，求该图各结点的入度数

void indegreenum(ALGraph g){
  int degree[g.vexnum];
  for(int i=0;i<g.vexnum;i++)degree[i]=0;
  for(int i=0;i<g.vexnum;i++){
    ArcNode p;
    p=g.vertices[i].first;
    degree[p->adjvex]++;
    p=p->next;
  } 
}

六、设计一个算法，统计一个采用邻接矩阵存储、具有n个顶点的无向无权图所有顶点的度

void indegreenum(MGraph g){
  int degree[g.vexnum];
  for(int i=0;i<g.vexnum;i++){
    degree[i]=0;
  }
  for(int i=0;i<g.vexnum;i++){
    for(int j=0;j<g.vexnum;j++){
      if(g.arcnum[i][j]!=0){
        degree[i]+=2;
      }
    }
  } 
}

七、已知某有向图用邻接表表示，删除数据值为key的结点

void deletekey(ALGraph g, int key)
{
  int i = 0;
  for (i = 0; i < g.vexnum; i++)
  {
    if (g.vertices[i].data == key)
      break;
  }
  ArcNode p = g.vertices[i].first;
  ArcNode q, u;
  while (p)
  {
    u = p;
    p = p->next;
    free(u);
  }
  for (int j = 0; j < g.vexnum; j++)
  {
    if (j != i)
    {
      p = q = g.vertices[j].first;
      if (p->adjvex == i)
      {
        u = p;
        g.vertices[j].first = p->next;
        p = p->next;
        free(u);
      }
      else
      {
        while (p)
        {
          if (p->adjvex == i)
          {
            u = p;
            q->next = p->next;
            p = p->next;
            free(u);
          }
          if (p->adjvex > i)
            p->adjvex--;
          q = p;
          p = p->next;
        }
      }
    }
  }
  for(int j=i+1;j<g.vexnum;j++){
    g.vertices[j-1]=g.vertices[j];
  }
}

八、图的深度遍历（递归）

//递归
int visited[Max]={0};
void DFS(ALGraph g,int v)
{
  visit(v);
  visited[v]=1;
  ArcNode p=g.vertices[v].first;
  while(p){
    if(!visited[p->adjvex]){
      DFS(g,p->adjvex);
    }
    p=p->next;
  }
}

九、图的广度遍历

int visited[Max]={0};
void BFS(ALGraph g,int v){
  visit(v);
  visited[v]=1;
  int Queue[Max],front=-1,rear=0;
  Queue[0]=v;
  while(front<rear){
    v=Queue[++front];
    ArcNode p=g.vertices[v].first;
    while (p)
    {
      if(!visited[p->adjvex]){
        visit(p->adjvex);
        visited[p->adjvex]=1;
        Queue[++rear]=p->adjvex;
      }
      p=p->next;
    }
    
  }
}

十、图的深度遍历（非递归）

void DFS(ALGraph g,int v)
{
  int Stack[Max],top=-1;
  visited[v]=1;
  Stack[++top]=v;
  while(top!=-1){
    v=Stack[top--];
    visit(v);
    ArcNode p=g.vertices[v].first;
    while(p){
      if(!visited[p->adjvex]){
        Stack[++top]=p->adjvex;
        visited[p->adjvex]=1;
      }
      p=p->next;
      }
  }
  
}