java图的邻接表实现两种方式及实例应用分析

最新推荐文章于 2023-12-04 18:26:03 发布
最新推荐文章于 2023-12-04 18:26:03 发布
阅读量1.7w 收藏 60
点赞数 19
文章标签： java 图 邻接表 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feilong_csdn/article/details/69321375
版权

本篇博客来谈一谈图的邻接表实现的两种方式，首先我们明确一点“学会图的邻接表实现的关键点在于“：你所建立的图的邻接表的对象是什么！

首先我们看一下《算法导论》中关于图的邻接表的定义：图G=(V,E)的邻接表表示有一个包含 |V| 个列表的数组Adj所组成，其中每个列表对应于V中的一个顶点，对于每一个u∈V，邻接表Adj[u]包含所有满足条件（u，v）∈E的顶点v，亦即，Adj[u]包含图G中所有和顶点u相邻的顶点。（或者他也可能指向这些顶点的指针），每个邻接表中的顶点一般以任意的顺序存储。（注意一下这句话！）

图的邻接表表示如下图所示：

这里写图片描述

定义总是比较晦涩难懂的，下面我们从如何实现图的邻接表表示来谈一谈！
1、邻接表构建图是必须需要一个Graph对象，也就是图对象！该对象包含属性有：顶点数、边数以及图的顶点集合；

2、正如上面所说，邻接链表的对象首先我们需要确定邻接表的对象，可以用顶点作为邻接链表的对象，自然也可以用边作为邻接链表的对象！下面将分别对这两种方式进行讲解！

一、邻接链表使用顶点作为对象构建图

1、Graph对象类

/**
 * 自定义图类
 * @author King
 */
public class Graph1 {
    Vertex1[] vertexArray=new Vertex1[100];
    int verNum=0;
    int edgeNum=0;
}

2、Vertex对象类

/**
 * 图的顶点类
 * @author King
 */
public class Vertex1 {
    String verName;
    Vertex1 nextNode;
}

3、图的实现类

import java.util.Scanner;

public class CreateGraph3 {

    /**
     * 根据用户输入的string类型的顶点返回该顶点
     * @param graph 图
     * @param str 输入数据
     * @return返回一个顶点
     */
    public Vertex1 getVertex(Graph1 graph,String str){
        for(int i=0;i<graph.verNum;i++){
            if(graph.vertexArray[i].verName.equals(str)){
                return graph.vertexArray[i];
            }
        }
        return null;
    }

    /**
     * 根据用户输入的数据初始化一个图，以邻接表的形式构建!
     * @param graph 生成的图
     */
    public void initialGraph(Graph1 graph){
        @SuppressWarnings("resource")
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入顶点数和边数：");
        graph.verNum=scan.nextInt();
        graph.edgeNum=scan.nextInt();

        System.out.println("请依次输入定点名称：");
        for(int i=0;i<graph.verNum;i++){
            Vertex1 vertex=new Vertex1();
            String name=scan.next();
            vertex.verName=name;
            vertex.nextNode=null;
            graph.vertexArray[i]=vertex;
        }

        System.out.println("请依次输入图的便边：");
        for(int i=0;i<graph.edgeNum;i++){
            String preV=scan.next();
            String folV=scan.next();

            Vertex1 v1=getVertex(graph,preV);
            if(v1==null)
                System.out.println("输入边存在图中没有的顶点！");

//下面代码是图构建的核心：链表操作
            Vertex1 v2=new Vertex1();
            v2.verName=folV;
            v2.nextNode=v1.nextNode;
            v1.nextNode=v2;

//紧接着下面注释的代码加上便是构建无向图的，不加则是构建有向图的！
//          Vertex1 reV2=getVertex(graph,folV);
//          if(reV2==null)
//              System.out.println("输入边存在图中没有的顶点！");
//          Vertex1 reV1=new Vertex1();
//          reV1.verName=preV;
//          reV1.nextNode=reV2.nextNode;
//          reV2.nextNode=reV1;
        }
    }

    /**
     * 输入图的邻接表
     * @param graph 待输出的图
     */
    public void outputGraph(Graph1 graph){
        System.out.println("输出图的邻接链表为：");
        for(int i=0;i<graph.verNum;i++){
            Vertex1 vertex=graph.vertexArray[i];
            System.out.print(vertex.verName);

            Vertex1 current=vertex.nextNode;
            while(current!=null){
                System.out.print("-->"+current.verName);
                current=current.nextNode;
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        Graph1 graph=new Graph1();
        CreateGraph3 createGraph=new CreateGraph3();
        createGraph.initialGraph(graph);
        createGraph.outputGraph(graph);
    }
}

二、邻接链表使用边作为对象构建图

1、Graph对象类

import java.util.ArrayList;

public class Graph {

    ArrayList<Vertex> vertexList=new ArrayList<Vertex>();
    int vertexNum=0;
    int edgeNum=0;
    public Graph(){}
}

2、Edge对象类

/**
 * 图的边对象类
 * @author King
 */
public class Edge {
    int edgeName;
    Edge next;

    public Edge(){
    }
}

3、Vertex对象类<这里顶点对象只是辅助边构建图，不是作为邻接链表的对象>

/**
 * 图的点对象类
 * @author King
 */
public class Vertex {
    String vertexName;
    Edge firstEdge=new Edge();
    public Vertex(){
    }
}

4、图的实现类

import java.util.Scanner;
/**
 * 通过构建边和点的对象来创建图
 * @author King
 */
public class CreateGraph {

    /**
     * 根据顶点信息String，返回边的对象
     * @param graph 图
     * @param str 顶点名称
     * @return 返回的是边对象的标签
     */
    public int vtoe(Graph graph,String str){
        for(int i=0;i<graph.vertexNum;i++){
            if(graph.vertexList.get(i).vertexName.equals(str)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 该函数用于图的初始化的实现
     * @param graph 图
     */
    public void initialGraph(Graph graph){
        @SuppressWarnings("resource")
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入顶点数和边数：");
        graph.vertexNum=scan.nextInt();
        graph.edgeNum=scan.nextInt();

        System.out.println("请依次输入定点名称：");
        for(int i=0;i<graph.vertexNum;i++){
            Vertex vertex=new Vertex();
            String name=scan.next();
            vertex.vertexName=name;
            vertex.firstEdge=null;
            graph.vertexList.add(vertex);
        }

        System.out.println("请依次输入每个边：");
        for(int i=0;i<graph.edgeNum;i++){
            String preV=scan.next();
            String folV=scan.next();
            int v1=vtoe(graph,preV);
            int v2=vtoe(graph,folV);
            if(v1==-1 || v2==-1)
                System.out.println("输入顶点数据错误！");

//下面代码是图构建的核心：链表操作
            Edge edge1=new Edge();
            edge1.edgeName=v2;
            edge1.next=graph.vertexList.get(v1).firstEdge;
            graph.vertexList.get(v1).firstEdge=edge1;

//          下面代码加上便是构建无向图，不加便是构建有向图
//          Edge edge2=new Edge();
//          edge2.edgeName=v1;
//          edge2.next=graph.vertexList.get(v2).firstEdge;
//          graph.vertexList.get(v2).firstEdge=edge2;
        }
    }

    /**
     * 输出图的邻接链表表示
     * @param graph 图
     */
    public void outputGraph(Graph graph){
        Edge edge=new Edge();
        for(int i=0;i<graph.vertexNum;i++){
            System.out.print(graph.vertexList.get(i).vertexName);

            edge=graph.vertexList.get(i).firstEdge;
            while(edge!=null){
                System.out.print("-->"+graph.vertexList.get(edge.edgeName).vertexName);
                edge=edge.next;
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        CreateGraph createGraph=new CreateGraph();
        Graph graph=new Graph();
        createGraph.initialGraph(graph);
        createGraph.outputGraph(graph);
    }
}

5、以上面给出的图片中图为例运行结果展示：

这里写图片描述

三、使用邻接表构建图的实例

问题：随机生成一个图（可以是有向图或是无向图），图的顶点大概100个左右，若是有向图则边大概2000条左右，若是无向图则边大概1000条左右！并计算出边的入度和出度

代码：
1、Graph类

public class GraphRandom {

    VertexRandom[] vertexArray=new VertexRandom[200];
    int verNum=0;
    int edgeNum=0;
}

2、Vertexl类

public class VertexRandom {

    int verName;
    int inRadius,outRadius;
    VertexRandom nextNode;
}

3、随机图实现类

import java.util.Scanner;
/**
 * 随机生成一个图，计算每个顶点的入度和出度
 * @author King
 *
 */
public class CreateGraph2 {

    /**
     * 由顶点名称返回顶点集合中的该顶点
     * @param graph 图
     * @param name 顶点名称
     * @return返回顶点对象
     */
    public VertexRandom getVertex(GraphRandom graph,int name){
        for(int i=0;i<graph.verNum;i++){
            if(graph.vertexArray[i].verName==name){
                return graph.vertexArray[i];
            }
        }
        return null;
    }

    /**
     * 该顶点通过顶点和边构建图
     * @param graph 图
     */
    public void randomSpanning(GraphRandom graph){
        @SuppressWarnings("resource")
        Scanner scan=new Scanner(System.in);
        System.out.println("请输入随机图的顶点个数：");
        graph.verNum=scan.nextInt();

        for(int i=1;i<=graph.verNum;i++){
            VertexRandom vertex=new VertexRandom();
            vertex.verName=i;
            vertex.nextNode=null;
            graph.vertexArray[i-1]=vertex;
        }

        int number=(int)(Math.random()*200+1000);
        System.out.println("随机生成的边的数量为："+number);
        graph.edgeNum=number;

        for(int i=0;i<graph.edgeNum;i++){
            int preV=(int)(Math.random()*100+1);
            int folV=(int)(Math.random()*100+1);
            while(folV==preV){
                folV=(int)(Math.random()*100+1);
            }

            VertexRandom vertex1=getVertex(graph,preV);
            if(vertex1==null)
                System.out.println("随机图中没有该顶点！");
            VertexRandom vertex2=new VertexRandom();
            vertex2.verName=folV;
            vertex2.nextNode=vertex1.nextNode;
            vertex1.nextNode=vertex2;

//          下面用于计算顶点的出度和入度的
            vertex1.outRadius++;
            VertexRandom v2=getVertex(graph,folV);
            if(v2==null)
                System.out.println("随机图中没有该顶点！");
            v2.inRadius++;

//          加上下面代码用于产生无向图
//          VertexRandom reVertex2=getVertex(graph,folV);
//          if(reVertex2==null)
//              System.out.println("随机图中没有该顶点！");
//          VertexRandom reVertex1=new VertexRandom();
//          reVertex1.verName=preV;
//          reVertex1.nextNode=reVertex2.nextNode;
//          reVertex2.nextNode=reVertex1;
        }
    }

    /**
     * 输出图的邻接链表
     * @param graph 图
     */
    public void outputGraph(GraphRandom graph){
        System.out.println("输出图的邻接链表为：");
        for(int i=0;i<graph.verNum;i++){
            VertexRandom vertex=graph.vertexArray[i];
            System.out.print(vertex.verName);

            VertexRandom current=vertex.nextNode;
            while(current!=null){
                System.out.print("-->"+current.verName);
                current=current.nextNode;
            }
            System.out.println();
        }
    }

    /**
     * 输出图的入度和出度
     * @param graph 图
     */
    public void IORadius(GraphRandom graph){
        for(int i=0;i<graph.verNum;i++){
            System.out.print("顶点"+(i+1)+"的出度为："+graph.vertexArray[i].outRadius);
            System.out.println(",入度为："+graph.vertexArray[i].inRadius);
        }
    }

    public static void main(String[] args) {
        GraphRandom graph=new GraphRandom();
        CreateGraph2 createGraph2=new CreateGraph2();
        createGraph2.randomSpanning(graph);
        createGraph2.outputGraph(graph);
        createGraph2.IORadius(graph);
    }
}
CHEONG_KG
关注
  • 19
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
java数据结构之图（邻接矩阵和邻接表）
xxniuren的专栏
08-16 2万+
JAVA数据结构之图 1、图的介绍和原理 1.1、图的基本概念 图是由顶点集（VertexSet）和边集（EdgeSet）组成，针对图G，顶点集和边集分别记为V(G)和E(G)。依据图的边集是否为有向，可把图分为有向图和无向图，根据图是否有权重，可以分为有权图和无权图。 图的基本术语： 1：邻接点----在一个无向图中，若存在一条边（Vi，Vj），则称Vi，Vj为此边的两个端点，并称它们
邻接表（Java）
贱贱的梦想
03-11 3889
无向图的邻接表结构如下所示： 无向图的邻接表的代码实现： /* * 邻接表无向图（已提供参数） * 输入说明：vexs -- 顶点数组 * edges -- 边数组 * 输出说明：邻接表（即每个顶点所连接的点） */ package test; public class ListUDG { int vlen; // 顶点个数 int elen
邻接表有向图 之 Java详解
Code-lover's Learning Notes
08-18 8138
邻接表有向图的介绍邻接表有向图是指通过邻接表表示的有向图。上面的图G2包含了”A,B,C,D,E,F,G”共7个顶点，而且包含了”邻接表有向图的代码说明1. 基本定义public class ListDG { // 邻接表中表对应的链表的顶点 private class ENode { int ivex; // 该边所指向的顶点的位置 EN
Java实现无向图的邻接列表表示，深度遍历及广度遍历
qq_40985985的博客
05-25 1040
图1. 图的表示2. 图的分类3. 图的表示4. 图的遍历5. 源码5.1 图的邻接列表表示5.1 邻接列表宽度优先、深度优先遍历 1. 图的表示 图用 G = （V，E）表示。V表示顶点集，E表示每条边。 n = |V|, m = |E|, 表示有 n个顶点，m条边。 顶点n 与 边数m 的关系：m ——（n-1 ~ n^2)之间； 2. 图的分类 图根据边有无方向，分为有向图、无向图； 图根据顶点数与边数的关系，分为稀疏图、稠密图。 顶点数n与边数m大致呈线性关系的为稀疏图，顶点数n与边数m大致呈
Java数据结构-有向图实验，使用邻接表构建有向图
最新发布
zs18056175178的博客
12-04 1122
算法设计 采用邻接表存储有向图，设计算法判断任意两个顶点间是否存在路径。 提示： 1.建立图 2.利用深度优先遍历，寻找到一个节点 3.基于找到的节点，查找邻接表，判断是否存在这样的路径
java实现图的邻接表存储结构的两种方式及实例应用详解
08-25
Java 实现图的邻接表存储结构的两种方式及实例应用详解 本文主要介绍了 Java 实现图的邻接表存储结构的两种方式及实例应用详解。图的邻接表是一种常用的图存储结构，它将图的顶点和边信息存储在一个数组中，使得图...
邻接表无向图的Java语言实现完整
08-28
邻接表无向图的Java语言实现完整 邻接表无向图是一种常见的图数据结构，它通过邻接表表示无向图。在Java语言中，实现邻接表无向图需要定义相应的数据结构和算法。下面是关于邻接表无向图的Java语言实现的知识点： ...
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
图的邻接表实现.rar
05-25
C++实现图的邻接表，利用了类模板，可以构建有向图和无向图，包含链表、图的ADT，里面附有说明文档，详细说明了主程序的测试方式。
Java实现链表中的闭环检测算法
DevNinja的博客
09-24 104
链表是一种常见的数据结构，其中每个节点都包含一个指向下一个节点的引用。在某些情况下，链表可能会形成闭环，也就是说链表中的一个节点的引用指向之前已经遍历过的节点。因此，检测链表中是否存在闭环是一项重要的任务。如果链表中存在闭环，那么快指针最终会追上慢指针，它们会指向同一个节点。如果链表中不存在闭环，那么快指针最终会到达链表的末尾，即。通过这个算法，我们可以有效地检测链表中是否存在闭环，避免在处理链表时出现无限循环等问题。方法是用来检测链表中是否存在闭环的核心算法。方法中，我们创建了一个有闭环的链表作为示例。
用邻接表实现图的数据结构
01-03
用邻接表实现图的数据结构，链表方式实现，win32+vs2013
日撸 Java 三百行（36 天: 邻接表的代码实现)
ALBlack的博客
04-17 2404
这里是JAVA自学与了解的同步笔记与记录，如有问题欢迎指正说明
蓝桥杯 历届试题 危险系数 深度搜索java代码实现
ethonyLight的博客
05-15 704
题目如下：这个题说实话博主我折腾了两个晚上，因为图论知识的缺乏，后来在中国大学mooc上的浙大的数据结构课程上看了一点，想到了解法，一开始我走向了用求割点的方法，但是我没有做出来，因为学到的割点算法求的是整个网络中的割点，本题求的是两个精确点的割点，不好解决，那么我们换一个思路，设置一个数组，保存每个节点在所有路径方案上出现的次数，先通过深度遍历的方式遍历从起点到终点的所有路径，找的时候给所有能够...
java创建邻接表
Luolimasi的博客
08-04 2176
邻接表 主要适用于 点较多而边较少的情况。可以减少占用空间 package 图; import java.util.Scanner; public class AdjacencyList {//实现 邻接表 static class Node{ char data;//结点数据 int index;//邻接点 在数组中的坐标 Node next;//指针 int weight;//存储 两个点之间 边的权值 边表中才用得到 } int vexnum,edgenum;//边数和
java 有向图_邻接表有向图(三)之 Java详解
weixin_40006965的博客
02-12 375
邻接表有向图的介绍邻接表有向图是指通过邻接表表示的有向图。上面的图G2包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了",,,,,,,,"共9条边。上图右边的矩阵是G2在内存中的邻接表示意图。每一个顶点都包含一条链表，该链表记录了"该顶点所对应的出边的另一个顶点的序号"。例如，第1个顶点(顶点B)包含的链表所包含的节点的数据分别是"2,4,5"；而这"2,4,5"分别对应"C,E,F"的...
图的常用操作（邻接表，java实现）
qiuxinfa123的博客
11-06 4553
之前写过图的邻接矩阵表示及其常用操作https://blog.csdn.net/qiuxinfa123/article/details/83719789，这篇博客主要介绍邻接表的相关操作，包括图的建立、深度优先搜索、广度优先搜索、单源最短路径、多源最短路径、最小生成树的Prim和Kruskal算法。 先看下节点类型以及边的类型。 //作为某个点的邻接点的顶点信息 class Node{ ...
java使用邻接表实现图
热门推荐
morris
06-30 1万+
邻接表实现图 图的表示方式有两种： 邻接矩阵（Adjacency Matrix） 邻接表（Adjacency List） 本文采用类似邻接表的方式实现图。 图的基础接口 public interface Graph<V, E> { int verticesSize(); // 顶点数量 int edgesSize(); // 边的数量 void addVertex(V v); // 添加顶点 void addEdge(V from, V to); //
用邻接表表示图【java实现】
yiihsia的学习阵地
06-21 1万+
自己用java写了个图数据结构的简单实现，可以设置有向图和无向图。该类还实现了迭代方法，广度优先和深度优先源代码：package my.graph; import java.util.ArrayList; import java.util.Iterator; import my.queue.*; import my.stack.StackX; /** * 邻接表表示 * @author xiayi * */ public class Graph { private int M
图的存储结构之邻接表
鸭梨的博客
05-16 6612
什么是邻接表? 邻接表（Adjacency List）是图的一种顺序存储与链式存储结合的存储方法。 对于图G中的每个顶点Vi，将所有邻接于Vi的顶点Vj链成一个单链表，这个单链表就称为顶点Vi的邻接表，再将所有顶点的邻接表表头放到数组中，就构成了图的邻接表。 在邻接表表示中，包括两种结点结构。 一个是顶点结点，每个顶点结点由2个域组成，其中data域存储顶点Vi的名或其相关信息，firstArc指向顶点Vi的第一个邻接点的边结点；- 第二个是边结点，边结点由3个域组成。其中abjVex域存放与Vi邻接的点
图的邻接表实现及应用的测试和分析
05-31
邻接表是一种常用的图的表示方法，它可以有效地存储稀疏图。邻接表的实现主要是使用链表来存储节点和边的信息。 在邻接表中，每个节点都对应一个链表，该链表存储与该节点相邻的节点。对于有向图，每个节点的链表存储该节点的出边，而对于无向图，则需要在每个节点的链表中同时存储该节点的入边和出边。 在应用方面，邻接表可以用来解决许多图论问题，例如最短路径、最小生成树、拓扑排序等。对于稀疏图，邻接表的存储效率要比邻接矩阵高，因为邻接矩阵需要存储大量的0值。 下面是一个基本的邻接表的实现代码： ```python class Graph: def __init__(self, vertices): self.V = vertices self.adj = [[] for i in range(vertices)] def add_edge(self, u, v): self.adj[u].append(v) self.adj[v].append(u) ``` 在实现了邻接表之后，我们可以对图进行各种操作。例如，我们可以使用广度优先搜索算法来查找两个节点之间的最短路径。下面是一个示例代码： ```python from collections import deque def bfs(graph, start, end): visited = [False] * graph.V queue = deque([(start, 0)]) visited[start] = True while queue: node, dist = queue.popleft() if node == end: return dist for neighbor in graph.adj[node]: if not visited[neighbor]: visited[neighbor] = True queue.append((neighbor, dist+1)) return -1 ``` 以上代码实现了广度优先搜索算法，用来查找两个节点之间的最短路径。我们可以通过将邻接表作为参数传递给bfs函数来使用它。 除了最短路径问题之外，邻接表还可以用来解决其他的图论问题，例如最小生成树、拓扑排序等。在实际应用中，我们可以根据问题的特点选择合适的算法和数据结构来解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值