数据结构 JAVA描述（六） 图的创建 （邻接矩阵+邻接表）

最新推荐文章于 2022-02-07 20:49:37 发布
最新推荐文章于 2022-02-07 20:49:37 发布
阅读量5.7k 收藏 20
点赞数 4
分类专栏： 数据结构 文章标签： java 数据结构 图 邻接矩阵 邻接表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuquan0071/article/details/50435570
版权

图的抽象数据类型描述

IGraph

package Graph;

/**
 * @description 图的抽象数据类型描述
 *  
 * @date  2015年12月30日
 */
public interface IGraph {

    void createGraph();
    /**
     * @description 返回图中顶点数 
     * @date  2015年12月30日
     */
    int getVexNum();  

    /**
     * @description 返回图中边数 
     * @date  2015年12月30日
     */
    int getArcNum() ;

    /**
     * @throws Exception 
     * @description 给定位置v，返回其对应的顶点值 
     * @date  2015年12月30日
     */
    Object getVex(int v) throws Exception;  

    /**
     * @description 给定顶点的值vex，返回其在图中的位置  
     * @date  2015年12月30日
     */
    int locateVex(Object vex);

    /**
     * @throws Exception 
     * @description 返回v的第一个邻接点  
     * @date  2015年12月30日
     */
    int firstAdjVex(int v) throws Exception;

    /**
     * @throws Exception 
     * @description 返回v相对于w的下一个邻接点  
     * @date  2015年12月30日
     */
    int nextAdjVex(int v, int w) throws Exception;
}

图的邻接矩阵的描述

GraphKind

package Graph;

/**
 * @description 图的类型 
 * 
 * @author liuquan
 * @date  2015年12月30日
 */
public enum GraphKind {
    UDG, // 无向图（UnDirected Graph）
    DG, // 有向图（Directed Graph）
    UDN, //无向网（UnDirected Network）
    DN, //有向网（Directed Network）
}

MGraph 

package Graph;

import java.util.Scanner;

/**
 * @description 图的邻接矩阵的描述 
 *  
 * @date  2015年12月30日
 */
public class MGraph implements IGraph{
    public final static int INFINITY = Integer.MAX_VALUE;
    private GraphKind kind; // 图的种类标志
    private int vexNum, arcNum; // 图的当前顶点数和边数
    private Object[] vexs; // 顶点
    private int[][] arcs;  // 邻接矩阵

    public MGraph(){
        this(null, 0, 0, null, null);
    }


    public MGraph(GraphKind kind, int vexNumi, int arcNum, Object[] vexs, int[][] arcs) { 
        this.kind = kind;
        this.vexNum = vexNumi;
        this.arcNum = arcNum;
        this.vexs = vexs;
        this.arcs = arcs;
    }


    /**
     * @description 图的创建算法 图的类型共有4种 
     *  
     * @date  2015年12月30日
     */
    public void createGraph() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入图的类型：（UDG、DG、UDN、DN）");
        GraphKind kind = GraphKind.valueOf(sc.next());
        switch (kind) {
        case UDG:
            createUDG();
            break;
        case DG:
            createDG();
            break;
        case UDN:
            createUDN();
            break;
        case DN:
            createDN();
            break;
        default:
            break;
        }
    }


    /**
     * @description 创建有向网
     *  
     * @date  2015年12月30日
     */
    private void createDN() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请分别输出图的顶点数、图的边数：");
        vexNum = sc.nextInt();
        arcNum = sc.nextInt();
        vexs = new Object[vexNum];
        System.out.println("请分别输出图的各个顶点：");
        for(int v = 0; v < vexNum; v++){
            vexs[v] = sc.next();
        }
        arcs = new int[vexNum][vexNum];
        // 初始化邻接矩阵
        for(int v = 0; v < vexNum; v++){
            for(int u = 0; u < vexNum; u++){
                arcs[v][u] = INFINITY;
            }
        }
        System.out.println("请输入各个边的两个顶点及其权值");
        for(int k = 0; k < arcNum; k++){
            int v = locateVex(sc.next());
            int u = locateVex(sc.next());
            arcs[v][u] = sc.nextInt();
        }
    }


    /**
     * @description 创建无向网 
     *  
     * @date  2015年12月30日
     */
    private void createUDN() { 
        Scanner sc = new Scanner(System.in);
        System.out.println("请分别输出图的顶点数、图的边数：");
        vexNum = sc.nextInt();
        arcNum = sc.nextInt();
        vexs = new Object[vexNum];
        System.out.println("请分别输出图的各个顶点：");
        for(int v = 0; v < vexNum; v++){
            vexs[v] = sc.next();
        }
        arcs = new int[vexNum][vexNum];
        // 初始化邻接矩阵
        for(int v = 0; v < vexNum; v++){
            for(int u = 0; u < vexNum; u++){
                arcs[v][u] = INFINITY;
            }
        }
        System.out.println("请输入各个边的两个顶点及其权值");
        for(int k = 0; k < arcNum; k++){
            int v = locateVex(sc.next());
            int u = locateVex(sc.next());
            arcs[v][u] = arcs[u][v] = sc.nextInt();
        }
    }


    /**
     * @description 创建有向图 
     *  
     * @date  2015年12月30日
     */ 
    private void createDG() {
        // 略 
    }


    /**
     * @description 创建无向图 
     *  
     * @date  2015年12月30日
     */
    private void createUDG() {
        // 略
    }


    public int getVexNum() { 
        return vexNum;
    }

    public int getArcNum() {  
        return arcNum;
    }

    /**
     * @description 根据顶点在数组中的位置返回顶点  
     * @date  2015年12月30日
     */
    public Object getVex(int v) throws Exception {        
        if(v < 0 && v >= vexNum)
            throw new Exception("第" + v + "个顶点不存在");
        return vexs[v];
    }

    /**
     * @description 顶点定位 根据顶点名返回其在数组中的位置  
     * @date  2015年12月30日
     */ 
    public int locateVex(Object vex) {  
        for(int v = 0; v < vexNum; v++){
            if(vexs[v].equals(vex))
                return v;
        }
        return -1;
    }

    /**
     * @description 查找第一个邻接点   
     * @date  2015年12月30日
     */
    public int firstAdjVex(int v) throws Exception { 
        if(v < 0 && v >= vexNum)
            throw new Exception("第" + v + "个顶点不存在");

        for(int j = 0; j < vexNum; j++){
            if(arcs[v][j] != 0 && arcs[v][j] < INFINITY){
                return j;
            }
        }
        return -1;
    }

    /**
     * @description 查找下一个邻接点，已知顶点v以及一个邻接点w，返回v相对于w的下一个邻接点 
     * @date  2015年12月30日
     */
    public int nextAdjVex(int v, int w) throws Exception { 
        if(v < 0 && v >= vexNum)
            throw new Exception("第" + v + "个顶点不存在");

        for(int j = w + 1; j < vexNum; j++){
            if(arcs[v][j] != 0 && arcs[v][j] < INFINITY){
                return j;
            }
        }
        return -1; 
    }   

    public void display(){
        for(int i = 0; i < vexNum; i++){
            for(int j = 0; j< vexNum; j++){
                if(arcs[i][j] == INFINITY) 
                    System.out.print("+ "); 
                else
                    System.out.print(arcs[i][j] + " ");
            }
            System.out.println();
        }
    } 

}

构造一个具有n个顶点和e条边的网的时间复杂度是O（n² + en），其中邻接矩阵的初始化耗费了O（n²）的时间。

图的邻接表的描述

ALGraph

package Graph;
import java.util.Scanner;

/**
 * @description 邻接表顶点结点结构
 *  
 * @date 2015年12月30日
 */
class VNode {

    private Object data; // 顶点信息

    private ArcNode firstArc; // 指向第一条依附于该顶点的弧

    public VNode() {
        this(null, null);
    }

    public VNode(Object data) {
        this(data, null);
    }

    public VNode(Object data, ArcNode firstArc) {
        this.data = data;
        this.firstArc = firstArc;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public ArcNode getFirstArc() {
        return firstArc;
    }

    public void setFirstArc(ArcNode firstArc) {
        this.firstArc = firstArc;
    }
}

/**
 * @description 邻接表 边（弧）的结点类
 *  
 * @date 2015年12月30日
 */
class ArcNode {

    private int adjVex; // 该弧所指向的顶点位置

    private int value; // 边的权值

    private ArcNode nextArc; // 指向下一条弧

    public ArcNode() {
        this(-1, 0, null);
    }

    public ArcNode(int adjVex) {
        this(adjVex, 0, null);
    }

    public ArcNode(int adjVex, int value) {
        this(adjVex, value, null);
    }

    public ArcNode(int adjVex, int value, ArcNode nextArc) {
        this.adjVex = adjVex;
        this.value = value;
        this.nextArc = nextArc;
    }

    public int getAdjVex() {
        return adjVex;
    }

    public void setAdjVex(int adjVex) {
        this.adjVex = adjVex;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public ArcNode getNextArc() {
        return nextArc;
    }

    public void setNextArc(ArcNode nextArc) {
        this.nextArc = nextArc;
    }
}

/**
 * @description 图的邻接表的描述 
 *  
 * @date  2015年12月30日
 */
public class ALGraph implements IGraph{ 

    private GraphKind kind; // 图的种类标志

    private int vexNum, arcNum; // 图的当前顶点数和边数

    private VNode[] vexs; // 顶点  

    public ALGraph(){
        this(null, 0, 0, null);
    }   


    public GraphKind getKind() {
        return kind;
    }

    public VNode[] getVexs() {
        return vexs;
    }


    public ALGraph(GraphKind kind, int vexNum, int arcNum, VNode[] vexs) {
        this.kind = kind;
        this.vexNum = vexNum;
        this.arcNum = arcNum;
        this.vexs = vexs;
    }

    /**
     * @description 图的创建算法 图的类型共有4种 
     *  
     * @date  2015年12月30日
     */
    public void createGraph() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入图的类型：（UDG、DG、UDN、DN）");
        GraphKind kind = GraphKind.valueOf(sc.next());
        switch (kind) {
        case UDG:
            createUDG();
            break;
        case DG:
            createDG();
            break;
        case UDN:
            createUDN();
            break;
        case DN:
            createDN();
            break;
        default:
            break;
        }
    }

    /**
     * @description 创建有向网
     *  
     * @date  2015年12月30日
     */
    private void createDN() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请分别输出图的顶点数、图的边数：");
        vexNum = sc.nextInt();
        arcNum = sc.nextInt();
        vexs = new VNode[vexNum];
        System.out.println("请分别输出图的各个顶点：");
        for(int v = 0; v < vexNum; v++){
            vexs[v] = new VNode(sc.next());
        } 
        System.out.println("请输入各个边的两个顶点及其权值");
        for(int k = 0; k < arcNum; k++){
            int v = locateVex(sc.next()); //弧尾 指出的点
            int u = locateVex(sc.next()); //弧头 被指入的点
            int value = sc.nextInt();
            addArc(v, u, value);
        }
    }


    /**
     * @description 创建无向网 
     *  
     * @date  2015年12月30日
     */
    private void createUDN() { 
        Scanner sc = new Scanner(System.in);
        System.out.println("请分别输出图的顶点数、图的边数：");
        vexNum = sc.nextInt();
        arcNum = sc.nextInt();
        vexs = new VNode[vexNum];
        System.out.println("请分别输出图的各个顶点：");
        for(int v = 0; v < vexNum; v++){
            vexs[v] = new VNode(sc.next());
        } 
        System.out.println("请输入各个边的两个顶点及其权值");
        for(int k = 0; k < arcNum; k++){
            int v = locateVex(sc.next()); //弧尾 指出的点
            int u = locateVex(sc.next()); //弧头 被指入的点
            int value = sc.nextInt();
            addArc(v, u, value);
            addArc(u, v, value);
        }
    }


    /**
     * @description 在位置v、u顶点之间，添加一条弧，其权值为value  
     * @date  2015年12月30日
     */
    private void addArc(int v, int u, int value) {
        ArcNode arc = new ArcNode(u,value);
        arc.setNextArc(vexs[v].getFirstArc());
        vexs[v].setFirstArc(arc); 
    }


    /**
     * @description 创建有向图 
     *  
     * @date  2015年12月30日
     */ 
    private void createDG() {
        // 略 
    }


    /**
     * @description 创建无向图 
     *  
     * @date  2015年12月30日
     */
    private void createUDG() {
        // 略
    }

    public int getVexNum() {
        return vexNum;
    }

    public int getArcNum() { 
        return arcNum;
    }

    /**
     * @description 根据顶点在数组中的位置返回顶点  
     * @date  2015年12月30日
     */
    public Object getVex(int v) throws Exception {        
        if(v < 0 && v >= vexNum)
            throw new Exception("第" + v + "个顶点不存在");
        return vexs[v].getData();
    }

    /**
     * @description 顶点定位 根据顶点名返回其在数组中的位置  
     * @date  2015年12月30日
     */ 
    public int locateVex(Object vex) {  
        for(int v = 0; v < vexNum; v++){
            if(vexs[v].getData().equals(vex))
                return v;
        }
        return -1;
    } 

    /**
     * @description 查找第一个邻接点  若没有邻接点则返回-1 
     * @date  2015年12月30日
     */
    public int firstAdjVex(int v) throws Exception { 
        if(v < 0 && v >= vexNum)
            throw new Exception("第" + v + "个顶点不存在");

        VNode vex = vexs[v]; 
        if(vex.getFirstArc() != null)
            return vex.getFirstArc().getAdjVex();
        else 
            return -1; 
    }

    /**
     * @description 查找v的相对于w位置的邻接点的下一个邻接点，如 v-a-b-w-c（a,b,w,c都是v的邻接点）,那么返回的就是c 
     * @date  2015年12月30日
     */
    public int nextAdjVex(int v, int w) throws Exception { 
        if(v < 0 && v >= vexNum)
            throw new Exception("第" + v + "个顶点不存在");

        VNode vex = vexs[v];
        ArcNode arcvw = null;
        for(ArcNode arc = vex.getFirstArc(); arc != null; arc = arc.getNextArc()){
            if(arc.getAdjVex() == w){
                arcvw = arc;
                break;
            }
        }
        if(arcvw != null && arcvw.getNextArc() != null)
            return arcvw.getNextArc().getAdjVex();
        else
            return -1;
    }   

    public void display() throws Exception{
        for(int i = 0; i < vexNum; i++){
            VNode vex = vexs[i];
            System.out.print(vex.getData());
            for(ArcNode arc = vex.getFirstArc(); arc != null; arc = arc.getNextArc()){
                System.out.print("->" + getVex(arc.getAdjVex()) +  arc.getValue());
            }
            System.out.println();
        }
    }
}

构造一个具有n个顶点和e条边的网的时间复杂度是O（en）

ToughMind_
关注
专栏目录
【创建图的邻接矩阵和邻接表】
xiongIT的博客
05-21 3806
1、假设带权有向图采用邻接矩阵存储。设计图的基本运算算法,包括创建图的邻接矩阵,输出图的邻接矩阵,销毁图的邻接矩阵。并用下图进行测试。 2、假设带权有向图采用邻接表存储。设计图的基本运算算法,包括创建图的邻接表,输出图的邻接表,销毁图的邻接表。并用下图进行测试。
图的邻接矩阵和邻接表实现
11-26
图的邻接矩阵和邻接表实现， 深度搜索， 广度搜索， Dijstra最短路径
java来构造邻接矩阵
wh柒八九的博客
12-30 392
使用java来构造邻接矩阵 “代码如下” FileUtil,java package com.gongjiao; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputSt...
java创建邻接矩阵
Luolimasi的博客
08-04 753
遍历后面再加 ，目前先写下创建。 package 图; import java.util.Scanner; public class Graph {//无向图 int edgenum,vexnum;//边数和点数 char[] vexs;//顶点表 int[][] arc;//邻接矩阵 public Graph(int vex,int edgenum) { this.vexs=new char[vex]; this.arc=new int[vex][vex]; } public v
邻接矩阵有向图(三)之 Java详解
kk的博客
05-11 514
前面分别介绍了邻接矩阵有向图的C和C++实现，本文通过Java实现邻接矩阵有向图。 目录 1. 邻接矩阵有向图的介绍 2. 邻接矩阵有向图的代码说明 3. 邻接矩阵有向图的完整源码 转载请注明出处：http://www.cnblogs.com/skywang12345/ 更多内容：数据结构与算法系列 目录 邻接矩阵有向图的介绍 邻接矩阵有向...
邻接表存储图Java实现
热门推荐
liangxiamoyi的博客
08-08 1万+
使用Java实现邻接表存储的图及其操作，深度优先遍历和广度优先遍历，拓扑排序，关键路径和最短路径问题。
Java数据结构——邻接矩阵+邻接表
NoBug
02-07 2774
{- 邻接矩阵, c, java} {- 邻接表, c, java。尾插法，挂接}
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
Java语言描述存储结构与邻接矩阵代码示例
08-28
总的来说，Java语言描述存储结构与邻接矩阵的代码示例提供了一种实现图数据结构的方法，尤其是针对邻接矩阵的实现。在选择存储结构时，开发者应考虑图的密度、空间效率和操作复杂性等因素，以选择最适合的方案。邻接...
基于java数据结构实验基于邻接矩阵和邻接表的深度广度优先遍历图.pdf
12-19
基于Java数据结构实验基于邻接矩阵和邻接表的深度广度优先遍历图 本实验报告的主要内容是基于Java数据结构实验，实验名称为“基于邻接矩阵和邻接表的深度广度优先遍历图”。实验的目的包括掌握图的相关概念、掌握用...
图的邻接矩阵和邻接表表示
06-10
图的C++的邻接表和邻接矩阵完整实现，功能齐全，运行界面效果好
java Excel创建矩阵的简单例子
04-14
java在一个Excel表格中创建一个矩阵的简单例子。。。。
2.2建立矩阵（Mat）
03-27
Java Opencv系列：（配套代码下载）2.2建立矩阵（Mat）
矩阵转置 java_Java 创建矩阵并转置矩阵
weixin_34800976的博客
02-20 297
/**from 时 代 J a v a - nowjava.com**/public class Main {public static void main(String args[]) throws Exception {int row = 4;int col = 3;int[][] mMatrix = new int[row][col];int r, c;for (r = 0; r < ...
java矩阵输入_opencv(Java)的矩阵创建与基础操作
weixin_27066963的博客
02-21 1799
opencv(Java)的矩阵创建与操作(1)创建矩阵OpenCV Java中矩阵就是一个类 Mat，和它扩展出来的MatOfDouble之类的类。通常创建一个矩阵对象的方法是：Mat A = new Mat(3, 4, CvType.CV_64FC1);或者分两步：Mat A = new Mat();A.create(3,4,CvType.CV_64FC1);矩阵使用完毕不用了，要记得销毁：A....
java自定义一个矩阵_JAVA之 简单构建一个矩阵并输出
weixin_28692867的博客
02-26 3211
package test;import java.util.Scanner;public class DEMO2 {public static void main(String[] args) {int m,n,min,i,j,row,col;Scanner s=new Scanner(System.in);System.out.println("请输入您想创建的矩阵的行数与列数,m为行，n为列"...
java邻接表无向图的创建_无向图的邻接表创建以及图的深度和…
weixin_36124208的博客
02-26 202
#define MAXSIZE 20#define FALSE 0#define TRUE 1#include#include#includeusing namespace std;typedef int Status;//…………………………………………队列结构……………………typedef struct qnode{int data;struct qnode *next;}qnode,*que...
矩阵的java程序怎么编写_如何编写Java程序以添加两个矩阵
weixin_42515512的博客
02-24 388
要添加两个矩阵-创建一个空矩阵在新矩阵的每个位置，从给定的两个矩阵分配相同位置的值之和，即，如果A [i] [j]和B [i] [j]是两个给定的矩阵，则c [i] [j]应该是A [i] [j] + B [i] [j]示例publicclassAddingTwoMatrices{publicstaticvoidmain(Stringargs[]){inta[][]={{1,2,3}...
java:自定义矩阵类
hanmo22357的博客
07-25 3973
/*我所设计的矩阵类包含以下功能:（不只是加法功能和转置功能） * 1.三种普通构造方法以及一种复制构造方法 * 2.矩阵的加法、减法、数乘、求负以及矩阵乘法的运算 * 3.矩阵的转置 * 4.矩阵的三种判断：矩阵是否同型、矩阵是否相等以及矩阵是否为方阵 * 5.计算矩阵的迹、矩阵中所有元素的和以及矩阵的乘方 * 6.获取矩阵的行数和列数 * 7.输出矩阵相关的所有信息 * 8.获取行列数确定的单位矩阵的静态方法
Java描述数据结构：邻接矩阵存储与图表示详解
在本课程中，我们将深入探讨数据结构的几种核心表示方法，包括图的数组（邻接矩阵）、邻接表、有向图的十字链表以及无向图的邻接多重表。这些内容是数据结构学科的重要组成部分，对于理解和实现计算机中的各种数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值