精华内容
下载资源
问答
  • 图的邻接表表示

    2017-11-28 13:44:02
    无向图的邻接表表示 有向图的邻接表表示 1.出边表:第I行边单链表存储以顶点vi为起点的所有边. 2.入边表:第j行边单链表存储以顶点vj为终点的所有边 有向图的邻接表表示有两种:1.由出边表构成...

    无向图的邻接表表示



    有向图的邻接表表示


    1.出边表:第I行边单链表存储以顶点vi为起点的所有边<vi,vj>.

    2.入边表:第j行边单链表存储以顶点vj为终点的所有边<vi,vj>

    有向图的邻接表表示有两种:1.由出边表构成邻接表 2.由入边表构成逆邻接表


    展开全文
  • 图的邻接表表示的克鲁斯卡尔算法 迪杰斯特拉算法 普里姆算法 c++实现 codeblocks编译通过
  • 图的邻接表表示法 pdf

    2015-04-03 16:03:02
    图的邻接表表示法: 1.邻接表的结点结构 2.无向图的邻接表 3.有向图的邻接表 4.有向图的逆邻接表 5.邻接表的形式说明及其建表算法 6.图的两种存储结构比较
  • 主要为大家详细介绍了C++实现有向图的邻接表表示,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 图的邻接表表示转换成邻接矩阵表示 typedef struct ArcNode { int adjvex;//该弧指向的顶点的位置 struct ArcNode *next;//下一条弧的指针 int weight;//弧的权重 } ArcNode; typedef struct { VertexType ...

    从图的邻接表表示转换成邻接矩阵表示

    typedef struct ArcNode
    {
    	int adjvex;//该弧指向的顶点的位置
    	struct ArcNode *next;//下一条弧的指针
    	int weight;//弧的权重
    } ArcNode;
    typedef struct
    {
    	VertexType data;//顶点信息
    	ArcNode *firstarc;
    } VNode,AdList[MAXSIZE];
    typedef struct
    {
    	int vexnum;//顶点数
    	int arcnum;//边数
    	AdList vertices;//邻接表
    } ALGraph; //用邻接表表示法
    
    
    typedef struct
    {
    	int vexnum;//顶点数
    	int arcnum;//边数
    	VertexType[MAXSIZE];//顶点数组
    	int AdjMatrix[MAXSIZE][MAXSIZE];//邻接矩阵
    } MGraph; //用邻接矩阵表示法
    
    
    MGraph *AdList_to_AdMatrix(ALGraph G)
    {
    	MGraph *GL = (MGraph*)malloc(sizeof(MGraph));
    	GL->vexnum = G.vexnum;//顶点数
    	GL->arcnum = G.arcnum;//边数
    
    	for(int i = 0; i < G.vexnum ; i++ )
    	{
    		GL->VertexType[i] = G.vertices[i].data;//顶点数组
    	}
    	for(int j = 0; j < G.vexnum; j++ )//初始化邻接矩阵
    	{
    		for(int k = 0; k < G.vexnum; k++ )
    		{
    			if(j == k)
    			{
    				GL->AdjMatrix[j][k] = 0;//在主对角线上,则为0
    			}
    			else
    			{
    				GL->AdjMatrix[j][k] = INFINITY;//否则为无穷
    			}	
    		}
    	}
    	for(int j = 0; j < G.vexnum; j++ )
    	{
    		ArcNode *p = G.vertices[j].firstarc;
    		for(int k = 0; k < G.vexnum; k++ )
    		{
    			if(p)//顶点j出发还有未访问的边
    			{
    				if(p->adjvex == k)
    				{
    					GL->AdjMatrix[j][k] = p->weight;//把权赋值到邻接矩阵里
    					p = p->next;
    				}
    			}
    			else//如果顶点j出发没有未访问的边了,则跳出这层循环
    				break;
    		}
    	}
    	return GL;
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    展开全文
  • 无向图的邻接表表示

    2012-10-15 16:19:48
    无向图的邻接表表示
  • 图的邻接表表示

    2019-09-08 12:01:46
    图的邻接表表示法 #include <cstdio> #include <string> #include <iostream> #include <algorithm> #define MaxVertexNum 1010 #define INF (1<<31)-1 using namespace std; //图...

    图的邻接表表示法

    #include <cstdio>
    #include <string>
    #include <iostream>
    #include <algorithm>
    #define MaxVertexNum 1010
    #define INF 65535
    
    using namespace std;
    
    //图的邻接矩阵表示法
    
    //边结构
    typedef struct ENode
    {
        int V1, V2;         //一组边
        int Weight;         //边的权重
    }*Edge;
    
    //邻接点结构
    struct AdjNode
    {
        int Adj;            //邻接点下标
        int Weight;         //边权重
        AdjNode *Next;      //指向下一个表头
    };
    
    //表头邻接点结构
    typedef struct VNode
    {
        AdjNode *Next;     //指向下一个邻接点
        int Data;           //顶点数据
    }*AdjList[MaxVertexNum];
    
    //图结构
    typedef struct GNode
    {
        int Vertex_num;     //顶点数目
        int EdgeNum;        //边数目
        AdjList G;          //邻接表
    }*Graph;
    
    //图初始化
    Graph InitGraph(int VertexNum)
    {
        Graph G;
    
        G = (Graph)malloc(sizeof(GNode));
        G->Vertex_num = VertexNum;
        G->EdgeNum = 0;
        for(int i = 0; i < G->Vertex_num; i++)
            G->G[i]->Next = NULL;
    
        return G;
    }
    
    //图中边的插入
    void InsertEdge(Graph G, Edge E)
    {
        AdjNode *NewNode;
        //为V2建立邻接点
        NewNode = (AdjNode*)malloc(sizeof(AdjNode));
        NewNode->Adj = E->V2;
        NewNode->Weight = E->Weight;
        //将V2插入V1的表头------头插法
        NewNode->Next = G->G[E->V1]->Next;
        G->G[E->V1]->Next = NewNode;
    
        //若为无向图
        //为V1建立邻接点
        NewNode = (AdjNode*)malloc(sizeof(AdjNode));
        NewNode->Adj = E->V1;
        NewNode->Weight = E->Weight;
        //将V1插入V2的表头
        NewNode->Next = G->G[E->V2]->Next;
        G->G[E->V2]->Next= NewNode;
    }
    
    Graph CreatGraph()
    {
        Graph G;
        Edge E;
        int Vertex;
        cin >> Vertex;
        G = InitGraph(Vertex);          //图初始化
        cin >> G->EdgeNum;              //输入边数
    
        if(G->EdgeNum)
        {
            E = (Edge)malloc(sizeof(ENode));
            for(int i = 0; i < G->EdgeNum; i++)
            {
                cin >> E->V1 >> E->V2 >> E->Weight;
                InsertEdge(G, E);       //将边插入G
            }
        }
    
        //输入顶点数据
        for(int i = 0; i < G->Vertex_num; i++) cin >> G->G[i]->Data;
    }
    
    int main()
    {
    
        return 0;
    }
    
    
    展开全文
  • 我原来实现的数据结构(C++):链式队列,顺序队列,二叉树,图的邻接矩阵表示,图的邻接表表示。供大家学习参考!
  • 图的邻接表表示转换成邻接矩阵表示的算法。 下面这个是有向图邻接表表示转换成邻接矩阵 #include #include #include int a[100][100];//邻接矩阵的载体 typedef struct ArcNode{ int adjvex; struct ...

    图的邻接表表示转换成邻接矩阵表示的算法。

    下面这个是有向图邻接表表示转换成邻接矩阵

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    int a[100][100];//邻接矩阵的载体 
    
    typedef struct ArcNode{
    	int adjvex;
    	struct ArcNode *nextarc;
    }ArcNode; //表结点 
    
    typedef struct VNode{
    	char data;
    	ArcNode *firstarc;	
    }VNode,AdjList[20];//头结点 
    
    typedef struct{
    	AdjList vertices;
    	int vexnum,arcnum;
    }ALGraph;//邻接表 
    
    int LocateVex(ALGraph G,char e)
    {
    	int i;
    	
    	for(i=0;i<G.vexnum;i++)
    	{
    		if(G.vertices[i].data==e)
    			return i;//找到后 返回i 
    	}
    	
    	return -1;
    }
    
    void CreatAdList(ALGraph &G)
    {//根据输入的有向图G的顶点数及边数,建立图G的邻接表
    	int i,j,k;
    	char v1,v2;
    	ArcNode *s,*p;
    	
    	scanf("%d%d",&G.vexnum,&G.arcnum);
    	getchar();
    	for(i=0;i<G.vexnum;i++) //初始化头结点 
    	{
    		scanf("%c",&G.vertices[i].data);
    		getchar();
    		G.vertices[i].firstarc=NULL;
    	}
    	for(i=0;i<G.vexnum;i++)//输出一遍这些头 
    	{
    		printf("%c ",G.vertices[i].data);
    	}
    	printf("\n");
    	for(k=0;k<G.arcnum;k++)
    	{//输入边 
    		scanf("%c %c",&v1,&v2);
    		getchar();
    		i=LocateVex(G,v1);
    		j=LocateVex(G,v2);
    		s= (ArcNode *)malloc(sizeof(ArcNode));
    		s->adjvex=j;
    		s->nextarc=NULL;
    		p=G.vertices[i].firstarc;
    		if(!p)
    		{
    			G.vertices[i].firstarc = s;
    		}
    		else
    		{
    			while(p->nextarc)
    				p=p->nextarc;
    			p->nextarc=s;
    		}
    	}
    }//CreateAdiMatrix
    
    void trans(ALGraph G)
    {//转换函数 
    	int i,j;
    	ArcNode *p;
    	
    	for(i=0;i<=G.vexnum;i++)//先初始化,全部赋值为0 
    		for(j=0;j<=G.vexnum;j++)
    		{
    			a[i][j]=0;
    		}
    	for(i=0;i<G.vexnum;i++)
    	{
    		p=G.vertices[i].firstarc;
    		while(p)
    		{
    			a[i][p->adjvex]=1;
    			p=p->nextarc;
    		}
    	}
    }
    
    void Output(ALGraph &G)
    {
    	int i,j;
    	
    	for(i=0;i<G.vexnum;i++)
    	{
    		for(j=0;j<G.vexnum;j++)
    		{
    			printf("%d ",a[i][j]);
    		}
    		printf("\n");
    	}
    		
    }
    
    int main()
    {
    	ALGraph G;
    
    	printf("有向图处理篇\n");
    	CreatAdList(G);
    	trans(G);
    	Output(G);
    		
    	return 0;
    }
    无向图邻接表表示转换成邻接矩阵

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    int a[100][100];//邻接矩阵的载体 
    
    typedef struct ArcNode{
    	int adjvex;
    	struct ArcNode *nextarc;
    }ArcNode; //表结点 
    
    typedef struct VNode{
    	char data;
    	ArcNode *firstarc;	
    }VNode,AdjList[20];//头结点 
    
    typedef struct{
    	AdjList vertices;
    	int vexnum,arcnum;
    }ALGraph;//邻接表 
    
    int LocateVex(ALGraph G,char e)
    {
    	int i;
    	
    	for(i=0;i<G.vexnum;i++)
    	{
    		if(G.vertices[i].data==e)
    			return i;//找到后 返回i 
    	}
    	
    	return -1;
    }
    
    void CreatAdList(ALGraph &G)
    {//根据输入的有向图G的顶点数及边数,建立图G的邻接表
    	int i,j,k,tmp;
    	char v1,v2;
    	ArcNode *s,*p;
    	
    	scanf("%d%d",&G.vexnum,&G.arcnum);
    	getchar();
    	for(i=0;i<G.vexnum;i++) //初始化头结点 
    	{
    		scanf("%c",&G.vertices[i].data);
    		getchar();
    		G.vertices[i].firstarc=NULL;
    	}
    	for(i=0;i<G.vexnum;i++)//输出一遍这些头 
    	{
    		printf("%c ",G.vertices[i].data);
    	}
    	printf("\n");
    	for(k=0;k<G.arcnum;k++)
    	{//输入边 
    		scanf("%c %c",&v1,&v2);
    		getchar();
    		i=LocateVex(G,v1);
    		j=LocateVex(G,v2);
    		s= (ArcNode *)malloc(sizeof(ArcNode));
    		s->adjvex=j;
    		s->nextarc=NULL;
    		p=G.vertices[i].firstarc;
    		if(!p)
    		{
    			G.vertices[i].firstarc = s;
    		}
    		else
    		{
    			while(p->nextarc)
    				p=p->nextarc;
    			p->nextarc=s;
    		}
    		tmp=i;
    		i=j;
    		j=tmp;
    		s= (ArcNode *)malloc(sizeof(ArcNode));
    		s->adjvex=j;
    		s->nextarc=NULL;
    		p=G.vertices[i].firstarc;
    		if(!p)
    		{
    			G.vertices[i].firstarc = s;
    		}
    		else
    		{
    			while(p->nextarc)
    				p=p->nextarc;
    			p->nextarc=s;
    		}
    	}
    }//CreateAdiMatrix
    
    void trans(ALGraph G)
    {//转换函数 
    	int i,j;
    	ArcNode *p;
    	
    	for(i=0;i<=G.vexnum;i++)//先初始化,全部赋值为0 
    		for(j=0;j<=G.vexnum;j++)
    		{
    			a[i][j]=0;
    		}
    	for(i=0;i<G.vexnum;i++)
    	{
    		p=G.vertices[i].firstarc;
    		while(p)
    		{
    			a[i][p->adjvex]=1;
    			p=p->nextarc;
    		}
    	}
    }
    
    void Output(ALGraph &G)
    {
    	int i,j;
    	
    	for(i=0;i<G.vexnum;i++)
    	{
    		for(j=0;j<G.vexnum;j++)
    		{
    			printf("%d ",a[i][j]);
    		}
    		printf("\n");
    	}
    		
    }
    
    int main()
    {
    	ALGraph G;
    
    	printf("有向图处理篇\n");
    	CreatAdList(G);
    	trans(G);
    	Output(G);
    		
    	return 0;
    }
    个人感觉无向图和有向图差别其实跟小,就是把下面这串代码复制一下,i,j换一下值就好了

    i=LocateVex(G,v1);
    		j=LocateVex(G,v2);
    		s= (ArcNode *)malloc(sizeof(ArcNode));
    		s->adjvex=j;
    		s->nextarc=NULL;
    		p=G.vertices[i].firstarc;
    		if(!p)
    		{
    			G.vertices[i].firstarc = s;
    		}
    		else
    		{
    			while(p->nextarc)
    				p=p->nextarc;
    			p->nextarc=s;
    		}
    版权,仅供参考。。。。。


    展开全文
  • python图的邻接表表示

    2021-04-12 14:46:01
    """图的邻接表表示""" class GraphNode(object): """节点类""" def __init__(self,_elem=None): self._elem = _elem # 数据域 self._next = None # 指针域 class Graph(object): """图类""" def __init__...
  • 总结: 1、邻接表表示由表头结点、...//无向图的邻接表表示法 #include <stdio.h> #include <stdlib.h> #define MaxVertexNum 100 typedef int Vertex; typedef int WeightType; typedef char DataType.
  • 图的邻接表表示法类似于树的孩子链表表示法。对于图G中的每个顶点vi,该方法把所有邻接于vi的顶点vj链成一个带头结点的单链表,这个单链表就称为顶点vi的邻接表(Adjacency List)。1. 邻接表的结点结构 (1)表结点...
  • 图的邻接表表示及其遍历1.图的结构定义#define MAXVEX 100 #define true 1 typedef char VertexType; //定义图节点值得类型,可随意更换 typedef int EdgeType; typedef struct EdgeNode //定义边表节点 { int ...
  • 图的邻接表表示及其遍历 1.图的结构定义 #define MAXVEX 100 #define true 1 typedef char VertexType; //定义图节点值得类型,可随意更换 typedef int EdgeType; typedef struct EdgeNode //定义边表节点 { int ...
  • C++图的邻接表表示方法

    千次阅读 2017-07-27 14:22:04
    C++图的邻接表表示方法 const int DefaultVertices = 100; template struct Edge{//边节点的定义 int dest;//边的另一顶点位置 E cost;//边上的权值 Edge *link;//下一条边链指针 Edge(){}//构造函数 Edge(int num...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,669
精华内容 1,467
关键字:

图的邻接表表示