#define SIZE 10

//邻接矩阵表示
typedef struct{
    int e_num;  //边数
    int v_num;  //顶点个数
    int links[SIZE][SIZE];   //邻接矩阵
    char vexs[SIZE];
}Graph1;

//邻接表表示
typedef struct edgeNode{    //边节点
    char vex;
    int value;
    struct edgeNode *next;
}edgeNode;

typedef struct vexNode{     //顶点节点
    char data;
    edgeNode *firstNode;
}Vexs[SIZE];

typedef struct{             //图
    int e_num;  //边数
    int v_num;  //顶点个数
    Vexs vex_arcs; //邻接表
}Graph2;


void trans(Graph1 *p, Graph2 *q){

    q->e_num = p->e_num;
    q->v_num = p->v_num;

    int i,j;
    for(i=0; i<p->v_num; i++){
        q->vex_arcs[i].data = p->vexs[i];
        q->vex_arcs[i].firstNode = NULL;
        
        for(j=0; j<p->v_num; j++){
            if(p->links[i][j] != 0){
            	//头插法
                edgeNode *new = (edgeNode *)malloc(sizeof(edgeNode));
                new->vex = p->vexs[j];
                new->next = q->vex_arcs[i].firstNode;
                q->vex_arcs[i].firstNode = new;
                
            }
        }
    }
}

package Graph;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class AdjMatrix {
	private int V;    //顶点个数
	private int E;    //边的个数
	private int[][] adj;  //邻接矩阵
	
	public AdjMatrix(String fileName) {
		File file=new File(fileName);
		try {
			Scanner scanner=new Scanner(file);
			V=scanner.nextInt();
			adj=new int[V][V];
			E=scanner.nextInt();
			for(int i=0;i<E;i++) {
				int a=scanner.nextInt();
				int b=scanner.nextInt();
				//数组相应位置处有顶点之间连接的赋值为1
				adj[a][b]=1;  
				adj[b][a]=1;
				
			}
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append(String.format("V = %d,E = %d\n",V,E));
		for(int i=0;i<V;i++) {
			for(int j=0;j<V;j++) {
				sb.append(String.format("%d\t", adj[i][j]));
			}
			sb.append('\n');
		}
		return sb.toString();
	}
	
	public static void main(String[] args) {
		AdjMatrix adj=new AdjMatrix("graph.txt");
		System.out.println(adj);
	}
}

得到的邻接矩阵如下所示：

V = 7,E = 9
0	1	0	1	0	0	0	
1	0	1	0	0	0	1	
0	1	0	1	0	1	0	
1	0	1	0	1	0	0	
0	0	0	1	0	1	0	
0	0	1	0	1	0	1	
0	1	0	0	0	1	0	

其中.txt文件中存储着无向图中的顶点个数、边的个数以及各个顶点之间的连接关系，如下所示

该案例中的无向图如下：

无向图邻接矩阵转换为邻接表

代码如下（C）：

#include <stdio.h>
#include<stdlib.h>
#define MAXV 100                
//以下定义邻接矩阵类型  
typedef struct                  
{
	int vexs[MAXV];      		 
    int arcs[MAXV][MAXV];       
    int vexnum,arcnum;          
} MGraph;                       
//以下定义邻接表类型
typedef struct ANode            
{
    int adjvex;                 
    struct ANode *nextarc;        
} ArcNode;
typedef struct Vnode           
{
    int data;                
    ArcNode *firstarc;         
} VNode;
typedef struct
{
    VNode vertices[MAXV];            
    int vexnum,arcnum;               
} ALGraph;                      
void MatToList(MGraph g,ALGraph *&G)
//将邻接矩阵g转换成邻接表G
{
    int i,j;
    ArcNode *p,*s;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    for (i=0; i<g.vexnum; i++)             
        G->vertices[i].firstarc=NULL;
    for (i=0; i<g.vexnum; i++)    
        for (j=0; j<g.vexnum; j++)
            if (g.arcs[i][j]!=0) 
            {
	 			p=(ArcNode *)malloc(sizeof(ArcNode)); 
	            p->adjvex=j; p->nextarc=NULL;
				if(!G->vertices[i].firstarc)
					G->vertices[i].firstarc=p;
				else{
					s=G->vertices[i].firstarc;
					while(s->nextarc) s=s->nextarc;
					s->nextarc=p;
				}
            }
    G->vexnum=g.vexnum;
    G->arcnum=g.arcnum;
}
void Output(ALGraph *G)
//输出邻接表G
{
    int i;
    ArcNode *p;
    for (i=0; i<G->vexnum; i++)
    {
        p=G->vertices[i].firstarc;
        printf("v%d:",i+1);
        while (p!=NULL)
        {
            printf("%2d",p->adjvex);
            p=p->nextarc;
        }
        printf("\n");
    }
}
int main()
{
    int i,j;
    MGraph g;//定义图的邻接矩阵 
    ALGraph *G;//邻接表 
    int n,m;
    printf("输入图G的邻接矩阵顶点数:\n");
    scanf("%d",&n);
    printf("输入图G的邻接矩阵边数:\n");
    scanf("%d",&m);
    int A[n][n];//邻接矩阵 
    printf("输入图G的邻接矩阵:\n");
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<n; j++)
        {
        	scanf("%d",&A[i][j]);
        }
    }
    g.vexnum=n;
    for (i=0; i<g.vexnum; i++)
        for (j=0; j<g.vexnum; j++)
            g.arcs[i][j]=A[i][j];
    printf("图G的邻接矩阵转换成邻接表:\n");
    MatToList(g,G);
    Output(G);
    return 0;
}

运行结果：

欢迎大家关注我