精华内容
下载资源
问答
  • 1#include#include/*定义边节点*/structarcnode{intadjvex;/*另一个顶点的下标*/intweight;/*边的权值*/structarcnode*next;/*指向下一条边的指针*/char*info;//isoption};/*定义顶点节点的类型*/structvnode{...

    1

    #include 

    #include 

    /*

    定义边节点

    */

    struct arcnode{

    int adjvex; /*

    另一个顶点的下标

    */

    int weight;/*

    边的权值

    */

    struct arcnode *next;/*

    指向下一条边的指针

    */

    char *info;

    //is option

    };

    /*

    定义顶点节点的类型

    */

    struct vnode{

    char data;/*

    顶点字符名称

    */

    struct arcnode *first;/*

    指向边链表的头结点

    */

    };

    /*

    定义图的结构

    */

    struct graph{

    struct vnode vex[20];/*

    顶点集,用数组存储

    */

    int vexnum,arcnum;

    int kind;

    };

    /*

    功能:创建一个边节点

    参数:

    k,

    边另一个节点的下标

    w,

    边的权值

    返回值:指向新创建的边节点的指针

    */

    struct arcnode *newarc(int k,int w){

    struct arcnode *p;

    /*

    在堆上给边节点分配一块空间

    */

    p=(arcnode *)malloc(sizeof(struct arcnode));

    /*

    把边的数据放入边节点

    */

    p->adjvex = k;

    p->weight = w;

    p->next=NULL;

    return(p);

    }

    /*

    返回某个顶点在顶点数组中的下标

    */

    int locate(struct graph gr,char c){

    int s;

    for(s=0;s

    if(gr.vex[s].data==c)

    return s;

    }

    }

    main(){

    展开全文
  • 邻接表建立C语言

    2020-02-03 16:06:18
    程序实现邻接表建立C语言入门小程序,适合C语言课程入门的小练习。
  • 邻接表(c语言)

    2017-12-14 23:46:55
    邻接表的操作,和其建立结构体的相关分析。
    #include <stdio.h>
    #include <malloc.h>
    typedef char DataType;
    #define MaxVertices 10


    按个人理解:首先观察邻接表整体,里面包含一个数组,数组里面最后一个元素是一个头指针,头指针中包含得是一个单向链表,由此可以建立结构体。可以从小开始看,也可以从大开始看,这里我从大开始看,首先邻接表结构体AdjLGraph,里面元素应该有数组,现在为了方便操作,外加边数目元素和顶点数目元素,然后数组结构体AdjLHeight,里面应该有数据元素、下标元素、头指针元素,接着,同样的道理,头指针里应有一个单链表,即单链表结构体Edge。最后为了方便操作,试验数据可以用一个结构体存储,即RowCol。


    typedef struct Node
    {
    int dest;//邻接边的弧头顶点序号
    struct Node *next;//单链表的下一个结点指针
    }Edge;//邻接边单链表的结点结构体


    typedef struct
    {
    DataType data;
    int source;
    Edge *adj;
    }AdjLHeight;//数组结构体


    typedef struct
    {
    AdjLHeight a[MaxVertices];//数组
    int numOfVertices;
    int numOfEdges;
    }AdjLGraph;//邻接表结构体


    //边信息的结构体
    typedef struct
    {
    int row;
    int col;
    }RowCol;


    //邻接表初始化
    void AdjInitiate(AdjLGraph *G)
    {
    int i;
    G->numOfVertices=0;
    G->numOfEdges=0;
    for(i=0;i<MaxVertices;i++)
    {
    G->a[i].source=i;
    G->a[i].adj=NULL;
    }
    }


    //插入顶点
    void InsertVertex(AdjLGraph *G,int i,DataType vertex)
    {
    if(i>=0 && i<MaxVertices)
    {
    G->a[i].data=vertex;
    G->numOfVertices++;
    }
    else
    {
    printf("顶点越界!");
    }
    }


    //插入边
    void InsertEdge(AdjLGraph *G,int v1,int v2)
    {
    Edge *p;
    if(v1<0 || v1>=G->numOfVertices  || v2<0 || v2>=G->numOfVertices)
    {
    printf("参数v1或v2越界!");
    return;
    }
    p=(Edge *)malloc(sizeof(Edge));
    p->dest=v2;
    p->next=G->a[v1].adj;
    G->a[v1].adj=p;
    G->numOfEdges++;
    }


    //创建图
    void CreatGraph(AdjLGraph *G,DataType v[],int n,RowCol d[],int e)
    {
    int i,k;
    AdjInitiate(G);
    for(i=0;i<n;i++)
    {
    InsertVertex(G,i,v[i]);
    }
    for(k=0;k<e;k++)
    {
    InsertEdge(G,d[k].row,d[k].col);
    }
    }


    //删除边
    void DeleteEdge(AdjLGraph *G,int v1,int v2)
    {
    Edge *curr,*pre;
    if(v1<0 ||v1>=G->numOfVertices || v2<0 || v2>=G->numOfVertices)
    {
    printf("参数v1或v2越界!");
    return;
    }
    pre=NULL;
    curr=G->a[v1].adj;
    while(curr!=NULL && curr->dest!=v2)
    {
    pre=curr;
    curr=curr->next;
    }
    if(curr!=NULL && curr->dest==v2 && pre==NULL)
    {
    G->a[v1].adj=curr->next;
    free(curr);
    G->numOfEdges--;
    }
    else if(curr!=NULL && curr->dest==v2 && pre!=NULL)
    {
    pre->next=curr->next;
    free(curr);
    G->numOfEdges--;
    }
    else
    {
    printf("边不存在!");
    }
    }


    //取第一个邻接顶点
    int GetFirstVex(AdjLGraph G,int v)
    {
    Edge *p;
    if(v<0 || v>=G.numOfVertices)
    {
    printf("参数v越界!");
    return -1;
    }
    p=G.a[v].adj;
    if(p!=NULL)
    {
    return p->dest;
    }
    else
    {
    return -1;
    }
    }


    //取下一个邻接顶点
    int GetNextVex(AdjLGraph G,int v1,const int v2)
    {
    Edge *p;
    if(v1<0 || v1>=G.numOfVertices || v2<0 || v2>=G.numOfVertices)
    {
    printf("参数v1或v2越界!");
    return -1;
    }
    p=G.a[v1].adj;
    while(p!=NULL)
    {
    if(p->dest!=v2)
    {
    p=p->next;
    continue;
    }
    else break;
    }
    p=p->next;
    if(p!=NULL)
    {
    return p->dest;
    }
    else
    {
    return -1;
    }
    }


    //撤销
    AdjDestroy(AdjLGraph *G)
    {
    int i;
    Edge *p,*q;
    for(i=0;i<G->numOfVertices;i++)
    {
    p=G->a[i].adj;
    while(p!=NULL)
    {
    q=p->next;
    free(p);
    p=q;
    }
    }
    }


    void main()
    {
    AdjLGraph g2;
    Edge *p;
    DataType v[]={'A','B','C','D','E'};//顶点集合
    int n=5;//顶点数目
    int e=6;//边数目
    int i,j;
    RowCol d[]={{0,1},{0,3},{3,1},{0,2},{2,4},{0,4}};//边集合
    CreatGraph(&g2,v,n,d,e);
    printf("顶点信息:\n");
    for(i=0;i<g2.numOfVertices;i++)
    {
    printf("%c ",g2.a[i].data);
    }
    printf("边信息:\n");
    for(i=0;i<g2.numOfVertices;i++)
    {
    printf("点%c的边有: ",g2.a[i].data);
    p=g2.a[i].adj;
    while(p!=NULL)
    {
    if(p->dest!=NULL)
    {
    printf("<%d,%d>",g2.a[i].source,p->dest);
    }
    p=p->next;
    }
    printf("\n");
    }
    printf("\n");
    DeleteEdge(&g2,0,4);
    printf("删除<0,4>边后:\n");
    for(i=0;i<g2.numOfVertices;i++)
    {
    printf("点%c的边有: ",g2.a[i].data);
    p=g2.a[i].adj;
    while(p!=NULL)
    {
    if(p->dest!=NULL)
    {
    printf("<%d,%d>",g2.a[i].source,p->dest);
    }
    p=p->next;
    }
    printf("\n");
    }
    }
    展开全文
  • //建立图(邻接表) #define num 20//图中的顶点数量 struct Node { int date; struct Node* next; }; struct Head { char head_ele; int flag; struct Node* next; }; struct Map//建立图的结构体 { int vex,...

    以邻接表表示图结构是一种简单易懂的方式,将数组与链表结合使用。如下图所示,数组存储顶点,每个数组元素后挂载着一串链表(与此顶点相连的顶点的信息)
    在这里插入图片描述
    下面看一下我的定义的几个结构体,Map结构体就是一个图,vex,edge,tag存储图的各个信息,还有一个struct Head类型的数组head,这就是上图的数组
    接着下面就能看见struct Head结构体里面定义的各种变量,head_ele就是定边存储顶点的信息(字母),flag判断该顶点是否被访问过,此程序不需要,但是后面的广度优先搜索和深度优先搜索会用到,还有个struct Node类型的指针变量,就用这个指针变量挂载每个顶点后的链表
    再看struct Node结构体里有什么,很简单,date存储相连的节点的数据,另一个就是指向下一个节点的指针变量(这是链表必需的,写过链表的应该都懂,没写过链表的话,这边建议亲先写几个链表呢)。

    在这里插入图片描述
    好,就结构体也讲完了,接下来说说整个程序的思路,很简单啊,输入一个从A到B的边,就先把B节点挂载到A下的链表中,再把A节点挂载在B下的链表中,然后就结束咯。
    至于详细步骤请各位看代码吧^ _ ^

    #include<stdio.h>
    //建立图(邻接表)
    #define MAX 20//图中的顶点数量
    struct Head//顶点
    {
    	char head_ele;
    	int flag;
    	struct Node* next;
    };
    struct Map//建立图的结构体
    {
    	int vex, edge, tag;//顶点,边,类型(1为有向图,0为无向图)
    	struct Head head[MAX];
    };
    struct Node//与顶点相连的节点
    {
    	int date;
    	struct Node* next;
    };
    void insert(struct Map* map, char from, char to);
    void creat(struct Map* map);
    void show(struct Map* map);
    //--------------------------------------------------------------------------------------------
    void creat(struct Map* map)
    {
    	int n;
    	char from = 'a', to = 'a';
    	struct Node* p;
    	printf("要建立几个顶点,几条边:");
    	scanf("%d%d", &(map->vex), &(map->edge));
    	getchar();
    	n = map->vex;
    	for (int i = 0; i < n; i++)
    	{
    		map->head[i].head_ele = i + 'A';
    		map->head[i].flag = 0;
    		map->head[i].next = NULL;
    	}
    	printf("请输入图的边\n");
    	for (int i = 0; i < map->edge; i++)
    	{
    		scanf("%c%c", &from, &to);
    		getchar();
    		if (from != ' ' && to != ' ' && from != to)
    		{
    			insert(map, from, to);//把to挂在from下
    			if (!(map->tag)) //tag:1为有向图,0为无向图
    				insert(map, to, from);//把from挂在to下
    		}
    	}
    }
    void insert(struct Map* map, char from, char to)
    {
    	if (map->head[from - 'A'].next)//判断该节点下是否已挂载链表,如果已挂载则进行比较,然后判断插入位置
    	{
    		if (map->head[from - 'A'].next->date > to - 'A')
    		{
    			struct Node* q = malloc(sizeof(struct Node));
    			q->date = to - 'A';
    			q->next = map->head[from - 'A'].next;
    			map->head[from - 'A'].next = q;
    		}
    		else
    		{
    			struct Node* p = map->head[from - 'A'].next;
    			struct Node* before = p;
    			while (p && (to - 'A' > p->date))
    			{
    				before = p;
    				p = p->next;
    			}
    			struct Node* q = malloc(sizeof(struct Node));
    			q->date = to - 'A';
    			q->next = before->next;
    			before->next = q;
    		}
    	}
    	else//如果没有挂载则直接将此节点挂载在该顶点下
    	{
    		map->head[from - 'A'].next = malloc(sizeof(struct Node));
    		map->head[from - 'A'].next->date = to - 'A';
    		map->head[from - 'A'].next->next = NULL;
    	}
    }
    
    void show(struct Map* map)
    {
    	for (int i = 0; i < map->vex; i++)
    	{
    		char ele = i + 'A';
    		struct Node* p = map->head[i].next;
    		printf("与%c连接的结点有:", ele);
    		while (p)
    		{
    			char ele = p->date + 'A';
    			printf("%c ", ele);
    			p = p->next;
    		}
    		printf("\n");
    	}
    }
    //-----------------------------------------------------------------------------------------------
    //AB BC CD AE EC FE FC DF EG GH FH FI
    int main()
    {
    	struct Map map;
    	printf("请选择建立有向图还是无向图(1为有向图,0为无向图):");
    	scanf("%d", &map.tag);
    	creat(&map);
    	show(&map);
    	return 0;
    }
    
    

    下面看个在vs2019下运行的结果
    在这里插入图片描述

    邻接表分享结束,各位有什么疑问可以在评论区留言,发现程序有bug告诉博主哦^ _ ^

    展开全文
  • /* 图的邻接表表示法 */ #define MaxVertexNum 100 /* 最大顶点数设为100 */ typedef int Vertex; /* 用顶点下标表示顶点,为整型 */ typedef int WeightType; /* 边的权值设为整型 */ typedef char DataType; /* ...

     

    /* 图的邻接表表示法 */
     
    #define MaxVertexNum 100    /* 最大顶点数设为100 */
    typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
    typedef int WeightType;        /* 边的权值设为整型 */
    typedef char DataType;        /* 顶点存储的数据类型设为字符型 */
     
    /* 边的定义 */
    typedef struct ENode *PtrToENode;
    struct ENode{
        Vertex V1, V2;      /* 有向边<V1, V2> */
        WeightType Weight;  /* 权重 */
    };
    typedef PtrToENode Edge;
     
    /* 邻接点的定义 */
    typedef struct AdjVNode *PtrToAdjVNode; 
    struct AdjVNode{
        Vertex AdjV;        /* 邻接点下标 */
        WeightType Weight;  /* 边权重 */
        PtrToAdjVNode Next;    /* 指向下一个邻接点的指针 */
    };
     
    /* 顶点表头结点的定义 */
    typedef struct Vnode{
        PtrToAdjVNode FirstEdge;/* 边表头指针 */
        DataType Data;            /* 存顶点的数据 */
        /* 注意:很多情况下,顶点无数据,此时Data可以不用出现 */
    } AdjList[MaxVertexNum];    /* AdjList是邻接表类型 */
     
    /* 图结点的定义 */
    typedef struct GNode *PtrToGNode;
    struct GNode{  
        int Nv;     /* 顶点数 */
        int Ne;     /* 边数   */
        AdjList G;  /* 邻接表 */
    };
    typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */
     
     
     
    LGraph CreateGraph( int VertexNum )
    { /* 初始化一个有VertexNum个顶点但没有边的图 */
        Vertex V;
        LGraph Graph;
         
        Graph = (LGraph)malloc( sizeof(struct GNode) ); /* 建立图 */
        Graph->Nv = VertexNum;
        Graph->Ne = 0;
        /* 初始化邻接表头指针 */
        /* 注意:这里默认顶点编号从0开始,到(Graph->Nv - 1) */
           for (V=0; V<Graph->Nv; V++)
            Graph->G[V].FirstEdge = NULL;
                 
        return Graph; 
    }
            
    void InsertEdge( LGraph Graph, Edge E )
    {
        PtrToAdjVNode NewNode;
         
        /* 插入边 <V1, V2> */
        /* 为V2建立新的邻接点 */
        NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
        NewNode->AdjV = E->V2;
        NewNode->Weight = E->Weight;
        /* 将V2插入V1的表头 */
        NewNode->Next = Graph->G[E->V1].FirstEdge;
        Graph->G[E->V1].FirstEdge = NewNode;
             
        /* 若是无向图,还要插入边 <V2, V1> */
        /* 为V1建立新的邻接点 */
        NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
        NewNode->AdjV = E->V1;
        NewNode->Weight = E->Weight;
        /* 将V1插入V2的表头 */
        NewNode->Next = Graph->G[E->V2].FirstEdge;
        Graph->G[E->V2].FirstEdge = NewNode;
    }
     
    LGraph BuildGraph()
    {
        LGraph Graph;
        Edge E;
        Vertex V;
        int Nv, i;
         
        scanf("%d", &Nv);   /* 读入顶点个数 */
        Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */ 
         
        scanf("%d", &(Graph->Ne));   /* 读入边数 */
        if ( Graph->Ne != 0 ) { /* 如果有边 */ 
            E = (Edge)malloc( sizeof(struct ENode) ); /* 建立边结点 */ 
            /* 读入边,格式为"起点 终点 权重",插入邻接矩阵 */
            for (i=0; i<Graph->Ne; i++) {
                scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
                /* 注意:如果权重不是整型,Weight的读入格式要改 */
                InsertEdge( Graph, E );
            }
        } 
     
        /* 如果顶点有数据的话,读入数据 */
        for (V=0; V<Graph->Nv; V++) 
            scanf(" %c", &(Graph->G[V].Data));
     
        return Graph;
    }

     

    展开全文
  • 邻接矩阵表示图 无权图实例: 1.图基本结构 #include<stdio.h> #include<malloc.h> #define MAXSIZE 100 /******* 邻接矩阵 *******/ typedef struct Gnode{ int nv ;//顶点 int ne ;//边 int G...
  • 邻接表是图的主要表示形式之一,是一种链接表表示方法。#include#include#define MAX 10//令图的最大顶点个数为10typedef struct node//边表结点(弧){int adjvex;//相连顶点的编号int weight;//边权struct node *...
  • 1 /*C语言建立有向图的邻接表及其遍历操作*/2 #include"stdio.h"3 #include"stdlib.h"4 //图的邻接矩阵储存结构5 typedef charelemtype;6 #define maxsize 107 #define queuesize 1008 //边结点的类型定义9 typedef ...
  • 由于看论文需要,最近自学数据结构到图这一章,用C语言写了一个使用邻接表建立图的程序,最后用BFS算法对顶点进行遍历,DFS较为简单,就不写了。 #include<stdio.h> #include<stdlib.h> #define ...
  • 请问为什么我建立邻接表的时候老是失败呢? #include #include #define MaxSize 100; //队列 typedef struct queue { int Front,Rear,MaxQueue; int Elements[100]; }Queue; int IsEmpty(Queue q) { return q....
  • 数据结构之图的邻接表C语言

    千次阅读 2018-06-14 23:27:20
    邻接表就是图的一种链式结构。对图中的每一个顶点Vi建立以个单链表来存放。邻接表中的每个单链表的第一个结点存放顶点的信息,并把这个结点看作链表的表头,其余结点存放与结点相关的信息。由此可知:邻接表有两张表...
  • 邻接表是图的主要表示形式之一,是一种链接表表示方法。 #include<stdio.h> #include<stdlib.h> #define MAX 10//令图的最大顶点个数为10 typedef struct node//边表结点(弧) { int adjve....
  • 程序用交互方式完成图的邻接矩阵和邻接表的构造,并提供了DFS和BFS算法。
  • 无向网邻接表建立和输出(C语言) 实施效果图片如下: c语言代码如下: #include <stdio.h> #include <stdlib.h> #define maxvex 100 typedef int EdgeType; /* 边上的权值类型 */ typedef struct...
  • 相信读者应该在书中也看到了邻接表表示的示意图了 在使用结构体是要注意命名的可读性和易读性 typedef struct graphy//用来表示网的关系 { int node_position;//结点下表位置 short int weight;//结点权值 ...
  • 本文主要向大家介绍了C/C++知识点之C语言建立有向图的邻接表及其遍历操作,通过具体的内容向大家展示,希望对大家学习C/C++知识点有所帮助。1/**/2#include"stdio.h"3#include"stdlib.h"4//图的邻接矩阵储存结构5...
  • C语言建立有向图的邻接表及其遍历操作

    千次阅读 多人点赞 2018-12-29 17:27:32
    C语言建立有向图的邻接表及其遍历操作 1 /*C语言建立有向图的邻接表及其遍历操作*/ 2 #include"stdio.h" 3 #include"stdlib.h" 4 //图的邻接矩阵储存结构 5 typedef char elemtype; 6 #...
  • 运用邻接表建立有向图,并进行深度遍历、广度遍历(c语言) 自认为深度和广度遍历的思路能够帮助大家更好地理解 #include<stdio.h> #include<stdlib.h> #include<malloc.h> #define OK 1 #define...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 129
精华内容 51
关键字:

邻接表建立c语言

c语言 订阅