精华内容
下载资源
问答
  • 图的邻接表存储
    2019-09-16 19:01:40

    用链表应该是比较麻烦的,可以用结构+数组实现

    struct Edge
    {
        int from,to,val,next;
    }edge[maxn];
    int edgenum;
    void addedge(int u,int v,int w)
    {
        edge[edgenum].from = u;
        edge[edgenum].to = v;
        edge[edgenum].val = w;
        edge[edgenum].next = head[u];//head[u]现在存储着u节点链接的最后一个节点
        head[u] = edgenum++;//现在u节点最后一个边就是edgenum了,所以head[u]记录一下它
    }

     

    更多相关内容
  • 领会的两种主要存储结构、基本运算算法和两种遍历算法设计内容:编写一个程序,设计带权的邻接矩阵与邻接表的创建和输出运算,并在此基础上设计一个主程序完成如下功能:(1)建立如所示的有向G的邻接矩阵...
  • 存储结构:邻接表; 实现功能:广度遍历; 为发布的博客的代码实现
  • 在我的的基本知识的博客中说到有两种存储方法,这个博客我来分享无向存储方式,邻接表法 名字中有邻接两个字,实际上就是跟邻接顶点有关的方法,也就是把邻接顶点,以链表的方式接在其相应顶顶点数组对应位置...

    在我的图的基本知识的博客中说到有两种存储方法,这个博客我来分享无向图的存储方式,邻接表法

    名字中有邻接两个字,实际上就是跟邻接顶点有关的方法,也就是把邻接顶点,以链表的方式接在其相应顶顶点数组对应位置的后面。如下图:
    在这里插入图片描述
    大概就是这样。
    那么我们要实现这种结构我们需要什么:
    1.表示顶点的字符串。
    2.表示存储顶点的数组。
    3.实现存储邻接顶点的链表,实际意义也就是边的意思。
    4.数组也要有个指针指向其所带的链表。
    所以得出结论就是,一个带着指针的数据数组,好多个链表节点以其规则指针链接。
    好,我们来实现基础工作,实现以上部分

    typedef char VertexType[4];//表示顶点
    //邻接链表
    typedef struct Arcnode {//表示边
    	int verindex;//顶点的序号
    	struct Arcnode* next;//表示下一个
    }NODE, *LPNODE;
    typedef struct VNode {//顶点节点
    	VertexType data;//顶点数据
    	LPNODE firstnode;//代表邻接链表的头节点
    }VNODE,*LPVNODE,ARRAY[10];
    typedef struct graph {
    	int arcnum;
    	int vexnum;
    	ARRAY vextex; //结构体数组
    }GR,*LPGR;
    

    大致包括完毕
    下面就是存储表的函数。
    我们分析一下我们需要干什么:
    我们需要知道几个顶点,几个边,然后就是插入,插入也就是无头链表头接法,但是这里要强调的是我们需要一个指针指向我们要插入的头节点位置,也就是我们需要数组顶点节点的二级指针。
    还有就是,我们AB边是不是就是A,B互为邻接顶点,所以我们插入需要两边都要插入
    插入的话,我们需要找到两顶点在数组的坐标才能插入,既然我们两个坐标都知道了,我们要是查询信息,我们可以用坐标查询,所以我们链表部分我们可以插入的数据插入为下标,不用再去费劲去查找字母了,复制字符串了
    所以,我们需要查找下标函数,,链表头接法函数,创建链表节点函数,一口气实现吧

    LPNODE createnode(int vexIndex) {
    	LPNODE newnode = (LPNODE)malloc(sizeof(NODE));
    	newnode->verindex = vexIndex;
    	newnode->next = NULL;
    	return newnode;
    }
    void insert(LPNODE* headnode, int vexindex) {
    	LPNODE newnode = createnode(vexindex);
    	newnode->next = *headnode;
    	*headnode = newnode;
    }
    int search(LPGR G, VertexType x) {
    	for (int i = 0; i < G->vexnum; i++) {
    		if (strcmp(x, G->vextex[i].data)==0) {
    			return i;
    		}
    	}
    	return -1;
    }
    LPGR creategraph() {
    	LPGR G = (LPGR)malloc(sizeof(GR));
    	printf("请输入要输入顶点和边的个数:");
    	scanf("%d%d", &G->vexnum, &G->arcnum);
    	printf("请输入%d个顶点\n", G->vexnum);
    	for (int i = 0; i < G->vexnum; i++) {
    		scanf("%s", G->vextex[i].data);
    		G->vextex[i].firstnode = NULL;
    	}
    	printf("请输入边的信息:\n");
    	VertexType v1, v2;
    	int posi;
    	int posj;
    	for (int i = 0; i < G->arcnum; i++) {//这里的查找跟上个矩阵法存储的插入查找坐标是一样的
    		scanf("%s%s", v1, v2);
    		posi = search(G, v1);
    		posj = search(G, v2);
    
    		//涉及到链表操作
    		insert(&G->vextex[posi].firstnode, posj);
    		insert(&G->vextex[posj].firstnode, posi);//相互反过来一插入就好
    	}
    	return G;
    }
    

    好了,我们的图邻接表法存储完毕了。
    下面是检验并打印的时刻到了。就拿最上面的图来检验一下吧:

    void print(LPGR G) {
    	for (int i = 0; i < G->vexnum; i++) {
    		printf("%s-->", G->vextex[i].data);
    		LPNODE pmove = G->vextex[i].firstnode;
    		while (pmove) {
    			printf("%s-->", G->vextex[pmove->verindex].data);
    			pmove = pmove->next;
    		}
    		printf("\n");
    	}
    }
    int main() {
    	LPGR G= creategraph();
    	print(G);
    	return 0;
    }
    

    打印结果如下:
    在这里插入图片描述
    发现存储的点是对的,顺序不对,这是因为,我们利用的是头节点插入法。


    好了,到这,基础的数据结构已经完毕了,面试考到的数据结构以链表队列二叉树居多,图结构实际上在工作中并不是很常见。

    展开全文
  • 主要介绍了java实现邻接表存储结构的两种方式及实例应用详解,邻接表构建是必须需要一个Graph对象,也就是对象!该对象包含属性有:顶点数、边数以及的顶点集合,需要的朋友可以参考下
  • 数据结构的邻接矩阵,邻接表存储表示,的深度优先搜索遍历,广度优先搜索遍历 数据结构的邻接矩阵,邻接表存储表示,的深度优先搜索遍历,广度优先搜索遍历.rar
  • 邻接表存储图

    2022-06-19 15:25:22
    邻接表的一种链式存储方法,其数据结构包括两部分:节点和邻接点。用邻接表可以表示无向,有向和网。在此用无向进行说明。包括节点信息 data 和指向第 1 个邻接点的指针 first。包括该邻接点的存储下标 v ...

    一 点睛

    邻接表是图的一种链式存储方法,其数据结构包括两部分:节点和邻接点。

    用邻接表可以表示无向图,有向图和网。在此用无向图进行说明。

    1 无向图

    2 无向图的链接表

    3 说明

    • 节点 a 的邻接点是节点 b、d,其邻接点的存储下标为1、3,按照头插法(逆序)将其放入节点 a 后面的单链表中。
    • 节点 b 的邻接点是节点 a、c、d,其邻接点的存储下标为0、2、3,按照头插法(逆序)将其放入节点 b 后面的单链表中。
    • 节点 c 的邻接点是节点 b、d,其邻接点的存储下标为1、3,按照头插法(逆序)将其放入节点 c 后面的单链表中。
    • 节点 d 的邻接点是节点 a、b、c,其邻接点的存储下标为0、1、2,按照头插法(逆序)将其放入节点 d 后面的单链表中。

    4 无向图邻接表的特点如下

    • 如果无向图中有 n 个节点、e 条边,则节点表中有 n 个节点,邻节点表有 2e 个节点。
    • 节点的度为该节点后面单链表中的节点数。

    二 邻接表的数据结构

    1 节点

    包括节点信息 data 和指向第 1 个邻接点的指针 first。

    2 邻接点

    包括该邻接点的存储下标 v 和指向下一个邻接点的指针 next,如果是网的邻接点,则还需增加一个权值域 w,如下图所示。

    三 算法步骤

    1 输入节点数和边数。

    2 依次输入节点信息,将其存储到节点数组 Vex[] 的 data 域中,将 Vex[] first 域置空。

    3 依次输入每条边依附的两个节点,如果是网,则还需要输入该边的权值。

    • 如果是无向图,则输入 a b,查询节点 a、b 在节点数组 Vex[] 中存储下标 i、j,创建一个新的邻接点 s,让 s.v = j;s.next=null;然后将节点 s 插入第 i 个节点的第 1 个邻接点之前(头插法)。在无向图中,从节点 a 到节点 b 有边,从节点 b 到节点 a 也有边,因此还需要创建一个新的邻接点 s2,让 s2.v = i;s2.next=null;然后让 s2 节点插入第 j 个节点的第 1 个邻接点之前(头插法)。
    • 如果是无向图,则输入 a b,查询节点 a、b 在节点数组 Vex[] 中存储下标 i、j,创建一个新的邻接点 s,让 s.v = j;s.next=null;然后将节点 s 插入第 i 个节点的第 1 个邻接点之前(头插法)。
    • 如果是无向网或有向网,则和无向图或有向图的处理方式一样,只是邻节点多了一个权值域。

    四 实现

    package graph;
    
    import java.util.Scanner;
    
    public class CreateALGraph {
        static final int MaxVnum = 100;  // 顶点数最大值
    
        public static void main(String[] args) {
            ALGraph G = new ALGraph();
            for (int i = 0; i < G.Vex.length; i++) {
                G.Vex[i] = new VexNode();
            }
            CreateALGraph(G); // 创建有向图邻接表
            printg(G); // 输出邻接表
        }
    
        static int locatevex(ALGraph G, char x) {
            for (int i = 0; i < G.vexnum; i++) // 查找顶点信息的下标
                if (x == G.Vex[i].data)
                    return i;
            return -1; // 没找到
        }
    
        // 插入一条边
        static void insertedge(ALGraph G, int i, int j) {
            AdjNode s = new AdjNode();
            s.v = j;
            s.next = G.Vex[i].first;
            G.Vex[i].first = s;
        }
    
        // 输出邻接表
        static void printg(ALGraph G) {
            System.out.println("----------邻接表如下:----------");
    
            for (int i = 0; i < G.vexnum; i++) {
                AdjNode t = G.Vex[i].first;
                System.out.print(G.Vex[i].data + ":  ");
                while (t != null) {
                    System.out.print("[" + t.v + "]\t");
                    t = t.next;
                }
                System.out.println();
            }
        }
    
        // 创建有向图邻接表
        static void CreateALGraph(ALGraph G) {
            int i, j;
            char u, v;
    
            System.out.println("请输入顶点数和边数:");
            Scanner scanner = new Scanner(System.in);
            G.vexnum = scanner.nextInt();
            G.edgenum = scanner.nextInt();
            System.out.println("请输入顶点信息:");
    
            for (i = 0; i < G.vexnum; i++)//输入顶点信息,存入顶点信息数组
                G.Vex[i].data = scanner.next().charAt(0);
            for (i = 0; i < G.vexnum; i++)
                G.Vex[i].first = null;
            System.out.println("请依次输入每条边的两个顶点u,v");
    
            while (G.edgenum-- > 0) {
                u = scanner.next().charAt(0);
                v = scanner.next().charAt(0);
                i = locatevex(G, u); // 查找顶点 u 的存储下标
                j = locatevex(G, v); // 查找顶点 v 的存储下标
                if (i != -1 && j != -1)
                    insertedge(G, i, j);
                else {
                    System.out.println("输入顶点信息错!请重新输入!");
                    G.edgenum++; // 本次输入不算
                }
            }
        }
    }
    
    // 定义邻接点类型
    class AdjNode {
        int v; // 邻接点下标
        AdjNode next; // 指向下一个邻接点
    }
    
    // 定义顶点类型
    class VexNode {
        char data; // VexType为顶点的数据类型,根据需要定义
        AdjNode first; // 指向第一个邻接点
    }
    
    // 定义邻接表类型
    class ALGraph {
        VexNode Vex[] = new VexNode[CreateALGraph.MaxVnum];
        int vexnum; // 顶点数
        int edgenum; // 边数
    }

    五 测试

    白色为输出,绿色为输入

    展开全文
  • 邻接表存储

    2019-08-25 14:20:25
    1、 定义邻接表存储类。 2、 实验验证如下算法的正确性、各种功能及指标: 1)创建一个邻接表存储; 2)返回中指定边的权值; 3)返回中某顶点的第一个邻接顶点; 4)返回中某顶点关于另一个顶点的下...
  • 采用邻接表来实现存储,并输入输出邻接表的信息,并用邻接表来实现的广度优先遍历。
  • (数据结构)邻接表存储结构

    千次阅读 2022-04-03 10:19:04
    邻接表存储图的实现方式:给图中的各个顶点独自建立一个链表,用节点存储该顶点,用另一个链表中的节点存储其邻接点 特殊之处是,为了便于管理这些链表,通常会将链表的头节点存储到数组中,也正因为各个链表的头...

    图的邻接表存储结构

    一般来说,图更多的是采用链表存储,具体的存储方法有 3 种,分别是邻接表、邻接多重表和十字链表


    本篇文章将优先介绍邻接表!!!

    邻接点:在图中,如果两个点相互连通,且通过其中一个顶点,可直接找到另一个顶点,则称它们互为邻接点

    邻接:指图中顶点之间有边或者弧的存在

    邻接表存储图的实现方式:给图中的各个顶点独自建立一个链表,用节点存储该顶点,用另一个链表中的节点存储其邻接点

    特殊之处是,为了便于管理这些链表,通常会将链表的头节点存储到数组中,也正因为各个链表的头节点存储的是各个顶点,因此各链表在存储邻接点数据时,仅需存储该邻接点位于数组中的位置下标

    图 1 邻接表存储有向图

            如上图 1 中,给图的各个顶点创建了一个链表(用于存储数据域和头指针域),然后创建一个数组用来保存各个顶点;之后给邻接点又创建一个链表(用于存储邻接点在数组中的位置下标和指向下一个邻接点的指针)

            对顶点 V1,与其相关的邻接点分别为 V2 和 V3,因此存储 V1 邻接点的链表中存储的是 V2 和 V3 在数组中的位置下标 1 和 2

            图 1 中的链接表结构用结构体声明如下:

    #define  MAX_NUM 20  // 最大顶点个数
    
    typedef enum{
    	DG, DN, UDG, UDN  // 依次代表的值为 0,1,2,3
    } GraphKind;  // 枚举图的 4 种类型
    
    typedef struct ArcNode{
        int adjvex;  // 邻接点在数组中的位置下标
        struct ArcNode *nextarc;  // 指向下一个邻接点的指针
        int *info;  // 信息域
    } ArcNode;
    
    typedef struct VNode{
        int data;  // 顶点的数据域
        ArcNode *firstarc;  // 指向邻接点的指针
    } VNode, AdjList[MAX_NUM];  // 存储各链表头结点的数组
    
    typedef struct{
        AdjList vertices;  // 图中顶点的数组
        int vexnum, arcnum;  // 记录图中顶点数和边或弧数
        GraphKind kind;  // 记录图的种类
    } ALGraph;

    邻接表计算顶点的出度和入度

    无向图:使用邻接表计算无向图中顶点的入度和出度只需从数组中找到该顶点然后统计此链表中节点的数量即可


    有向图:使用邻接表存储有向图时,通常各个顶点的链表中存储的都是以该顶点为弧尾的邻接点,因此通过统计各顶点链表中的节点数量,只能计算出该顶点的出度

    对于(有向图)利用邻接表求某顶点的入度,有两种方式:

    1. 遍历整个邻接表中的节点,统计数据域与该顶点所在数组位置下标相同的节点数量,即为该顶点的入度
    2. 建立一个逆邻接表,该表中的各顶点链表专门用于存储以此顶点为弧头的所有顶点在数组中的位置下标

    图 4 逆邻接表示意图

    展开全文
  • 主要介绍了邻接表存储表示,大家参考使用
  • 主要介绍了C++实现邻接表存储和广度优先遍历,实例分析了C++实现的存储与遍历技巧,非常具有实用价值,需要的朋友可以参考下
  • 1.生成一个100个点,3000条边的有向随机,任选一点作为源点,计算S到其他节点的距离。(注:邻接链表存储) 2.将实验一中的有向变为DAG。(从中去掉一些边,不允许用递归) 计算上述DAG中的最长路径。
  • 自行实现的邻接矩阵和邻接表存储结构 邻接矩阵类和邻接表类的实现及测试函数 功能全 代码易理解 可直接运行
  • 邻接表存储无向

    2021-05-20 12:55:16
    问题:还是把邻接表的结构体定义搞明白,就没那么难了^^代码:#include #include using namespace std;#define MAXV 20typedef struct edgeNode //边表节点{int data;struct edgeNode *next;}edgeList;typedef ...
  • 邻接表存储

    2012-11-11 13:00:37
    数据结构那本书上的邻接表存储 struct node { int vertex; struct node * nextnode; };
  • 建立的邻接矩阵或邻接表存储并在此基础上实现的深度优先遍历和广度优先遍历.doc
  • 任意给出个(本实验中使用有向)的存储方式,试设计一个程序,在计算机中完成 该的当前存储方式到另外一种存储方式的转换。
  • 邻接表实现无向存储结构,并进行深度优先搜索及广度优先搜索。
  • 的邻接矩阵和邻接表表示。广度优先搜索(BFS)、深度优先搜索(DFS)及 C++ 实现。
  • 邻接表存储及基本操作

    万次阅读 多人点赞 2017-12-10 22:54:32
    的存储方式有很多种,这里事宜邻接表存储为例实现的。的基本操作包括初始化一个空、插入一节点、插入条边、深度优先遍历、广度优先遍历、销毁等 #include #include #define OK 1 #define ERROR -1 #define ...
  • 新学期第一次数据结构作业,学了无向的邻接矩阵和邻接表存储,实现一下以邻接表存储的DFS和BFS。 #include <stdlib.h> #include <stdio.h> //无向的存储 typedef struct Arcnode{ int flag; ...
  • 【数据结构】图邻接表存储实现

    千次阅读 2014-04-29 21:46:45
    一个 G = (V,E)由顶点(vertex)集 V 和边(edge)集 E 组成。
  • 头歌数据结构邻接表存储及遍历操作 第1关邻接表存储及求邻接点操作 第2关的深度遍历 第3关的广度遍历 稳过
  • 建立有向邻接表存储并求出第i个顶点的出度并输出 有向邻接表表示 代码内容 #include<iostream> #define MVNum 100 //最大顶点数 #define OK 1; #define ERROR 0; typedef int Status; typedef char ...
  • 数据结构算法—邻接表存储的无向求连通分量个数 邻接表存储结构 typedef struct ArcNode{ int adjvex;//边指向的顶点 struct ArcNode *nextarc; // 下一条边的指针 }ArcNode; typedef struct VNode{ int data;...
  • 无向邻接表存储及输出无向邻接表存储及输出无向邻接表存储及输出
  • 的邻接矩阵存储和邻接表存储 代码完整 有注释,有需要的可以下载看看,基本是的邻接矩阵存储和邻接表存储 代码完整

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,056
精华内容 17,622
关键字:

图的邻接表存储

友情链接: 构造非平稳信号.rar