数据结构：图的存储的实现（邻接矩阵，邻接表）

最新推荐文章于 2024-01-25 20:03:39 发布
最新推荐文章于 2024-01-25 20:03:39 发布
阅读量859 收藏 3
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63544124/article/details/123162169
版权

邻接矩阵

 

 

 

 

 

 

public interface Graph<V> {

    int numOfVertex();//返回顶点的个数

    int numOfEdge();//返回边的个数

    void addVertex(V v);//增加一个顶点

    void addEdge(V from, V to);//增加一条边

    void addEdge(V from, V to, int weight);//增加一条带权值的边

    void removeVertex(V v);//删除一个顶点

    void removeEdge(V from, V to);//删除一条边

    void displayGraph();//显示一个图

    int degree(V v);//返回顶点v的度

}


//无向图的邻接矩阵存储
public class UndirectedMatrixGraph<V> implements Graph<V> {
    private ArrayList<V> vertexList;//存储顶点的集合
    private int[][] edgeMatrix;//存储边的邻接矩阵
    private int numOfVertex;//顶点的个数
    private int numOfEdge;//边的个数
    private int size;//顶点的最大规模
    private boolean[] isVisited;//记录顶点是否被访问

    public UndirectedMatrixGraph() {
    }

    public UndirectedMatrixGraph(int size) {
        this.size = size;
        vertexList = new ArrayList<V>(size);
        edgeMatrix = new int[size][size];
        numOfVertex = 0;
        numOfEdge = 0;
        isVisited = new boolean[numOfVertex];
    }

    @Override
    public int numOfVertex() {
        return this.numOfVertex;
    }

    @Override
    public int numOfEdge() {
        return this.numOfEdge;
    }

    @Override
    public void addVertex(V v) {
        this.vertexList.add(v);
        numOfVertex++;
    }

    @Override
    public void addEdge(V from, V to) {
        addEdge(from, to, 1);
    }

    @Override
    public void addEdge(V from, V to, int weight) {
        int i = vertexList.indexOf(from);
        int j = vertexList.indexOf(to);
        edgeMatrix[i][j] = weight;
        edgeMatrix[j][i] = weight;
        numOfEdge++;
    }

    @Override
    public void removeVertex(V v) {
        int index = vertexList.indexOf(v);//找到顶点的索引
        //所有的行向前移动一行
        for (int i = index; i < numOfVertex - 1; i++) {//拿到index这一行，和后面的每一行
            for (int j = 0; j < numOfVertex; j++) {//遍历某一行的所有元素
                edgeMatrix[i][j] = edgeMatrix[i + 1][j];//把每个元素上移
            }
        }
        //所有的列向前移动一行
        for (int i = 0; i < numOfVertex; i++) {
            for (int j = index; j < numOfVertex - 1; j++) {
                edgeMatrix[i][j] = edgeMatrix[i][j + 1];
            }
        }
        vertexList.remove(index);//从顶点的集合中删除这个顶点
        numOfVertex--;//顶点的个数-1
        //遍历邻接矩阵，得到依赖该顶点的边的条数从而调整边的总数
        for (int i = 0; i < numOfVertex; i++) {
            if (edgeMatrix[index][i] != 0) {
                numOfEdge--;
            }
        }
    }

    @Override
    public void removeEdge(V from, V to) {
        int i = vertexList.indexOf(from);
        int j = vertexList.indexOf(to);
        edgeMatrix[i][j] = 0;
        edgeMatrix[j][i] = 0;
        numOfEdge--;
    }

    @Override
    public void displayGraph() {
        System.out.println("这是一个无向图（邻接矩阵）");
        System.out.println("这个图的顶点是：" + vertexList);
        System.out.println("这个图的邻接矩阵是：");
        for (int i = 0; i < numOfVertex; i++) {
            for (int j = 0; j < numOfVertex; j++) {
                System.out.print(edgeMatrix[i][j] + "\t");
            }
            System.out.println();
        }
    }

    @Override
    public int degree(V v) {
        int n = 0;
        int index = vertexList.indexOf(v);
        for (int i = 0; i < numOfVertex; i++) {
            if (edgeMatrix[index][i] != 0) {
                n++;
            }
        }
        return n;
    }
}


public class GraphDemo {
    public static void main(String[] args) {
        Graph graph = new UndirectedMatrixGraph<Character>(6);

        //添加顶点
        graph.addVertex('A');
        graph.addVertex('B');
        graph.addVertex('C');
        graph.addVertex('D');
        graph.addVertex('E');
        graph.addVertex('F');

        //添加边
        graph.addEdge('A', 'B');
        graph.addEdge('A', 'D');
        graph.addEdge('B', 'C');
        graph.addEdge('B', 'E');
        graph.addEdge('C', 'D');
        graph.addEdge('C', 'F');
        graph.addEdge('D', 'F');
        graph.addEdge('E', 'F');

        graph.displayGraph();
        System.out.println("图的顶点数为" + graph.numOfVertex());
        System.out.println("图的边数为" + graph.numOfEdge());

        //删除顶点
        graph.removeVertex('B');
        graph.displayGraph();
        System.out.println("图的顶点数为" + graph.numOfVertex());
        System.out.println("图的边数为" + graph.numOfEdge());
        System.out.println("节点C的度为" + graph.degree('C'));
    }
}

邻接表

 

 

 

public interface Graph<V> {

    int numOfVertex();//返回顶点的个数

    int numOfEdge();//返回边的个数

    void addVertex(V v);//增加一个顶点

    void addEdge(V from, V to);//增加一条边

    void addEdge(V from, V to, int weight);//增加一条带权值的边

    void removeVertex(V v);//删除一个顶点

    void removeEdge(V from, V to);//删除一条边

    void displayGraph();//显示一个图

    int degree(V v);//返回顶点v的度

}



//无向图的邻接表存储
public class UndirectedLinkGraph<V> implements Graph<V> {

    class Vertex<V> {//内部类，存储顶点的信息
        V date;//顶点值
        LinkedList<Integer> adj;//顶点的每一个邻接顶点构成的邻接表，Integer为顶点在顶点数组中的下标

        //顶点的构造方法
        Vertex(V date) {
            this.date = date;
            adj = new LinkedList<Integer>();
        }

        public V getDate() {
            return date;
        }

        public LinkedList<Integer> getAdj() {
            return adj;
        }
    }

    Vertex<V>[] vertexList;//由顶点组成的数组
    int numOfVertex;//顶点的数量
    int numOfEdge;//边的数量
    int size;//顶点的最大规模

    UndirectedLinkGraph() {

    }

    UndirectedLinkGraph(int size) {
        vertexList = new Vertex[size];
        numOfVertex = 0;
        numOfEdge = 0;
    }

    @Override
    public int numOfVertex() {
        return numOfVertex;
    }

    @Override
    public int numOfEdge() {
        return numOfEdge;
    }

    @Override
    public void addVertex(V v) {
        vertexList[numOfVertex] = new Vertex<V>(v);
        numOfVertex++;
    }

    @Override
    public void addEdge(V from, V to) {
        addEdge(from, to, 1);
    }

    @Override
    public void addEdge(V from, V to, int weight) {
        //传入的是一个Vertex对象的顶点值
        //根据顶点值找这个Vertex对象在数组中的索引
        int i = getIndex(from);
        int j = getIndex(to);
        vertexList[i].adj.add(j);
        vertexList[j].adj.add(i);
        numOfEdge++;

    }

    //根据顶点值找这个Vertex对象在数组中的索引
    public int getIndex(V v) {
        for (int i = 0; i < numOfVertex(); i++) {
            if (vertexList[i].date == v) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public void removeVertex(V v) {
        int index = getIndex(v);
        //更新边的总数
        numOfEdge = numOfEdge - degree(v);
        //更新顶点的个数
        numOfVertex--;
        //删除边
        for (int i : vertexList[index].adj) {//遍历删除的这个顶点的邻接表，获取每邻接顶点一个值
            vertexList[i].adj.remove(new Integer(index));//删除邻接顶点的邻接表中被删除顶点的值
        }
        //删除这个顶点
        for (int i = index; i < numOfVertex - 1; i++) {
            vertexList[i] = vertexList[i + 1];
        }
        //更新邻接表中存储的被删除顶点后面的顶点的下标
        for (int i = 0; i < numOfVertex; i++) {
            for (int j = 0; j < vertexList[i].adj.size(); j++) {
                LinkedList<Integer> list = vertexList[i].adj;
                if (list.get(j) > index) {
                    list.set(j, list.get(j) - 1);
                }
            }
        }
    }

    @Override
    public void removeEdge(V from, V to) {
        int i = getIndex(from);
        int j = getIndex(to);
        vertexList[i].adj.remove(new Integer(j));
        vertexList[j].adj.remove(new Integer(i));
        numOfEdge--;
    }

    @Override
    public void displayGraph() {
        System.out.println("这是一个邻接表存储的无向图");
        for (int i = 0; i < numOfVertex; i++) {
            System.out.print("顶点：" + vertexList[i].date + "\t");
            System.out.println("邻接表：" + vertexList[i].adj);
        }
    }

    @Override
    public int degree(V v) {
        int i = getIndex(v);
        return vertexList[i].adj.size();
    }
}


public class GraphDemo {
    public static void main(String[] args) {
        Graph graph = new UndirectedLinkGraph<Character>(6);//邻接表测试

        //添加顶点
        graph.addVertex('A');
        graph.addVertex('B');
        graph.addVertex('C');
        graph.addVertex('D');
        graph.addVertex('E');
        graph.addVertex('F');

        //添加边
        graph.addEdge('A', 'B');
        graph.addEdge('A', 'D');
        graph.addEdge('B', 'C');
        graph.addEdge('B', 'E');
        graph.addEdge('C', 'D');
        graph.addEdge('C', 'F');
        graph.addEdge('D', 'F');
        graph.addEdge('E', 'F');

        graph.displayGraph();
        System.out.println("图的顶点数为" + graph.numOfVertex());
        System.out.println("图的边数为" + graph.numOfEdge());

        //删除顶点
        graph.removeVertex('B');
        graph.displayGraph();
        System.out.println("图的顶点数为" + graph.numOfVertex());
        System.out.println("图的边数为" + graph.numOfEdge());
        System.out.println("顶点C的度为" + graph.degree('C'));
    }
}

 

 

 

m0_63544124
关注
图的邻接表存储 c实现
玲玲的专栏
10-07 5万+
用到的数据结构是 一个是顶点表，包括顶点和指向下一个邻接点的指针 一个是边表， 数据结构跟顶点不同，存储的是顶点的序号，和指向下一个的指针 刚开始的时候把顶点表初始化，指针指向null。然后边表插入进来，是插入到前一个，也就是直接插入到firstedge指向的下一个，而后面
图的存储结构：邻接矩阵和邻接表
weixin_46432495的博客
10-08 2120
图 graph 顶点 vertex 弧 arc 弧尾 tail 弧头 head 有向图 digraph 边 edge 无向图 undigraph 权 weight 网 network 邻接点 adjacent 依附 incident 度 degree 出度 OutDegree 入度...
数据结构实验报告.docx
05-27
在图的邻接表存储结构中，顶点表用单链表储存，完成 1. 设计顶点表的结点结构， 2. 设计图的创建算法 3. 设计图的销毁算法 然后利用此存储结构完成图的的相关算法设计。 包括： 1.设计DFS算法 2.设计BFS算法 3.设计Prim算法 4.设计Kruskal算法 5.设计Dijkstra算法。 6.设计Floyd算法。
实现图的邻接矩阵和邻接表存储_**邻接矩阵对于无向图的理解
weixin_33634121的博客
01-27 382
对于图的构造我们有三种方法，第一种邻接矩阵，第二种邻接表，第三种十字链表。在这里我们深度解析 邻接矩阵与邻接表 的构造方法！首先我们阐述第一种方法: 邻接矩阵 (邻接矩阵用于相对来说比较稠密的无向图)例如此无向图:相对应的邻接矩阵表示如下:#include#include#define maxSize 10using namespace std;//在此声明 不用template 模板class ...
SCAU 8647 实现图的存储结构
Maoxim的博客
05-14 1787
8647 实现图的存储结构 时间限制:1000MS 代码长度限制:10KB 提交次数:1499 通过次数:1092 题型: 编程题 语言: G++;GCC Description 实现有向图的邻接矩阵存储结构。 输入格式 第一行：输入图的顶点个数n（各个顶点的默认编号为1~n）， 边的条数m。 第二 ~ m+1行：每行输入两个顶点编号i、j，表示连接顶点i到顶点j的一条边。 输出格式 分n行输出n*n的邻接矩阵，表示所输入的图存储，顶点i和顶点j之间如果有边相连，则输出1，没边相连则输出0。 输入样例
数据结构学习--图的邻接矩阵和邻接表存储
06-25
图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素表示图中顶点之间的边。对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
头歌数据结构图的邻接矩阵存储及遍历操作
05-26
### 头歌数据结构图的邻接矩阵存储及遍历操作 #### 一、邻接矩阵存储 在数据结构中，图是一种常见的非线性结构，用于表示对象间的关系。根据边是否有方向，图可以分为有向图和无向图。而根据边是否具有权重值，又...
python实现基本数据结构第四篇（图：字典存储，邻接矩阵存储，邻接表存储）
time_money的博客
10-26 3714
图是比树更复杂的一种数据结构。图中各个数据元素之间存在着多对多的关系，实际上日常生活中大部分关系都是图的关系，很多关系交错在一起就组成了一个规模很大的图，既然图这么重要，那么现在我们就谈谈如何在计算机中存储图这种数据元素存在多对多关系的数据结构。 当然，图分为无向图和有向图，至于基本概念，度娘里有很多，这里就不多赘述了。 图的字典形式存储python实现： 图中的每个顶点，都是字典中的键，和该顶点有边相连的顶点列表，就是该键的值。 class Graph(): def __init__(self):
图的存储结构与实现总结-java版
许诗宇的博客
05-21 4030
目录 图的存储结构 邻接矩阵 邻接表 两者区别 图的java实现 顶点 边 图 测试 图的存储结构 图的存储结构主要分两种，一种是邻接矩阵，一种是邻接表。 邻接矩阵 图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组（邻接矩阵）存储图中的边或弧的信息。 设图G有n个顶点，则邻接矩阵是一个n*n的方阵，定义为： 看一个实例，下图...
图的存储与实现
贪婪的君子
07-18 1366
图的实现图是一种非线性结构，其复杂程度要比树更甚一筹。图这种结构在数学领域中有自己专门的分支——即图论，在离散数学中有过简单的了解。
【数据结构】图邻接表存储实现
wenqian 'blog
04-29 9409
一个图 G = （V，E）由顶点（vertex）集 V 和边（edge）集 E 组成。
8、图的存储实现
没事发发博客
12-10 157
图的存储方式有邻接矩阵和邻接表两种基本存储方式，通过给你提供一个图的邻接矩阵存储对象，该对象的邻接矩阵已经赋值;请你将该图的邻接矩阵转换为邻接表存储的图对象，图的对象类型在提供给你的DSjar.jar归档文件中;你可以利用提供的库对象完成本题目的操作，在创建邻接表时，要求从编号小到大的顶点的边进行后插入，如果是无向图，也同样从编号小的顶点到编号大的顶点连接的边进行尾部插入。//创建邻接表图对象。输出：输出图的邻接表，依据顶点的次序每行输出一个顶点的邻接表信息。//输出邻接表图存储示例图。
图的存储结构实现
如梦山河的博客
10-24 333
源文件： #include <stdio.h> #include <stdlib.h> #define maxv 10 #define max 10 typedef char elem; typedef int elemtype; #include "queue.h" #include "mgraph.h" void main() { mgraph g; p...
【数据结构】图的存储结构及实现
SuperSources的博客
12-01 999
注意：图无法采用顺序存储结构！！！ 顶点之间的关系是m:n，即任何两个顶点之间都可能存在关系（边），无法通过存储位置表示这种任意的逻辑关系。 邻接矩阵（数组表示法） 1、基本思想： 用一个一维数组存储图中顶点的信息 用一个二维数组（称为邻接矩阵）存储图中各顶点之间的邻接关系。（边） 2、邻接矩阵 无向图 （1）无向图的邻接矩阵的特点？ 主对角线为 0 且一定是对称矩阵。 （2）如何求顶点i的度 ...
C语言 图的邻接矩阵和邻接表存储实现
最新发布
i13145821的博客
01-25 825
1、理解并掌握图的邻接矩阵存储；2、理解并掌握图的邻接表存储；3、实现两种存储结构。
实现图的邻接矩阵和邻接表的存储
GJG666的博客
11-30 5321
主程序“exp8-1.cpp”//图的基本运算算法 #include <stdio.h> #include <malloc.h> #include "graph.h" //------------------------------------------------------------ //----邻接矩阵的基本运算算法---------------------------------- //
C语言实现图数据结构：邻接表与邻接矩阵
"这篇资源是关于使用C语言实现图数据结构的源代码，包括邻接表和邻接矩阵两种方式。代码提供了创建无向图、输入边和顶点数的功能，并有简单的错误处理机制。" 在计算机科学中，图是一种重要的数据结构，用于表示...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值