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

考研数据结构

图的代码汇总（二）

一、已知无向图G，求图G的连通分量个数

int visited[Max]={0};
int Connectednum(ALGraph g){
  int num=0;
  for(int i=0;i<g.vexnum;i++){
    if(!visited[i]){
      num++;
      DFS(g,i);
    }
  }
  return num;
}
void DFS(ALGraph g,int v){
  visited[v]=1;
  ArcNode p=g.vertices[v].first;
  while(p){
    int j=p->adjvex;
    if(!visited[j]){
      DFS(g,j);
    }
    p=p->next;
  }
}

二、已知无向图采用邻接表存储方式，试写出删除边（i，j）的算法

void delete(ALGraph g, int i,int j){
  ArcNode p=g.vertices[i].first;
  ArcNode pre=p;
  if(p->adjvex==j){
    g.vertices[i].first=p->next;
    free(p);
  }else{
    p=p->next;
    while(p){
      if(p->adjvex==j){
        pre->next=p->next;
        free(p);
      }else{
        pre=p;
        p=p->next;
      }
    }
  }
  
}

三、判断以邻接表方式存储的有向图中是否存在由顶点vi到vj的路径

int visited[Max]={0};
int judgeitoj(ALGraph g, int i,int j){
  if(i==j){
    return 1
  }
  visited[i]=1;
  ArcNode p=g.vertices[i].first;
  while(p){
    if(!visited[p->adjvex]){
      return judgeitoj(g,p->adjvex,j);
    }
    p=p->next;
  }  
  return 0;
}

四、按图的宽度优先搜索法写一算法，判别以邻接矩阵存储的有向图中是否存在由顶点vi到顶点vj的路径

int judgeitoj(MGraph g, int i,int j){
  int Queue[Max],front=-1,rear=0;
  Queue[0]=i;
  while(front<rear){
    int u=Queue[++front];
    for(int k=0;k<g.vexnum;k++){
      if(g.Edge[u][k]==1&&k==j){
        return 1;
      }
      if(g.Edge[u][k]==1&&!visited[k]){
        visited[k]=1;
        Queue[++rear]=k;
      }
    }
  }
  return 0;
}

五、假设以邻接矩阵作为图的存储结构，编写算法，判定在给定的有向图中是否存在一个简单有向回路，若存在，则以顶点序列的方式输出该回路

int Topsort(MGraph g){
  int Stack[Max],top=-1;
  int num=0;
  for(int i=0;i<g.vexnum;i++){
    if(indegree[i]==0){
      Stack[++top]=i;
    }
  }
  while(top!=-1){
    num++;
    int p=Stack[top--];
    for(int i=0;i<g.vexnum;i++){
      if(g.Edge[p][i]!=0){
        indegree[i]--;
        if(indegree[i]==0){
          Stack[++top]=i;
        }
      }
    }
  }
  if(num==g.vexnum){
    return 1;
  }else{
     return 0;
  }
 
}

六、编写程序，判断一个用邻接表存储的有向图是否存在回路

int Topsort(ALGraph g){
  int Stack[Max],top=-1,num=0;
  for(int i=0;i<g.vexnum;i++){
    if(indegree[i]==0){
      Stack[++top]=i;
    }
  }
  while(top!=-1){
    num++;
    int j=Stack[++top];
    ArcNode p=g.vertices[j].first;
    while(p){
      int u=p->adjvex;
      indegree[u]--;
      if(indegree[u]==0){
        Stack[++top]=u;
      }
      p=p->next;
    }
  }
  if(num==g.vexnum){
    return 1;
  }else{
    return 0;
  }
}

七、在有向图G中，如果r到G中的每个结点都有路径可达，则称结点r为G的根节点，判断有向图G是否有根

void dfs(ALGraph g,int v){
  visited[v]=1;
  num++;
  if(num==g.vexnum){
    printf(v);
    num=0;
  }else{
    ArcNode p=g.vertices[v].first;
    while(p){
      int j=p->adjvex;
      if(!visited[j]) dfs(g,j);
      p=p->next;
    }
    num--;
    visited[v]=0;
  }
}
void rootnode(ALGraph g){
  for(int i=0;i<g.vexnum;i++){
    if(!visited[i]){
      dfs(g,i);
    }
  }
}

八、设无向图G用邻接表存储，试用宽度优先遍历写出求出图G中各联通分量个数的算法

int rootnode(ALGraph g){
  int num=0;
  for(int i=0;i<g.vexnum;i++){
    if(!visited[i]){
      bfs(g,i);
      num++;
    }
  }
  return num;
}
 void bfs(ALGraph g,int v){
  int Queue[Max],front=-1,rear=0;
  Queue[0]=v;
  while(front<rear){
    v=Queue[++front];
    visited[v]=1;
    ArcNode p=g.vertices[v].first;
    while (p)
    {
      int j=p->adjvex;
      if(!visited[j]){
        Queue[++rear]=v;
      }
      p=p->next;
    }
  }
 }

九、设计算法以判断给定的无向图G中是否存在一条以v0为起点的包含所有顶点的简单路径

int num=0,path[Max];
void dfs(ALGraph g,int v){
   visited[v]=1;
   path[num++]=v;
   if(num==g.vexnum){
    for(int i=0;i<g.vexnum;i++){
      printf(path[i]);
    }
   }else{
   ArcNode p=g.vertices[v].first;
   while(p){
      int j=p->adjvex;
      if(!visited[j]){
        dfs(g,j);
      }
      p=p->next;
    }
   }
}

十、已有邻接表表示的有向图，请编程判断从顶点u至顶点v是否有简单路径，若有则打印出该路径上所有顶点

void dfs(ALGraph g,int u,int v){
   visited[v]=1;
   int Stack[Max],top=-1;
   Stack[++top]=u;
   while(top!=-1){
    ArcNode p=g.vertices[v].first;
    while(p&&visited[p->adjvex]){
      p=p->next;
    }
    if(!p)top--;
    else{
      int j=p->adjvex;
      if(j==v){
        for(int i=0;i<top;i++){
          printf(Stack[i]);
        }
      }else{
        visited[j]=1;
        Stack[++top]=j;
      }
    }
  }
}