java 邻接表创建图

转载

Aceryt 2024-12-30 18:08:25

文章标签 java 邻接表创建图数据结构结点 System 邻接矩阵 文章分类 Java 后端开发

一、为什么要有图

前面学了线性表和树

线性表局限于一个直接前驱和一个直接后继的关系

树也只能有一个直接前驱也就是父节点

当我们需要表示多对多的关系时，我们就用到了图

二、图的常用概念

顶点 (vertex)

边 (edge)

路径

4) 无向图

5) 有向图

6) 带权图

java 邻接表创建图_java 邻接表创建图

java 邻接表创建图_邻接矩阵_02

三、图的存储结构

图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。

3.1 邻接矩阵

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1....n个点。

java 邻接表创建图_java 邻接表创建图_03

3.2 邻接表

邻接矩阵需要为每个顶点都分配 n 个边的空间，其实有很多边都是不存在 , 会造成空间的一定损失 .

2) 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成

java 邻接表创建图_邻接矩阵_04

四、图的创建与遍历

4.1 图的创建

我们使用邻接矩阵来表示图结构。使用集合来存储顶点，二维数组存储边的信息。

class Graph{
    protected List<String> vertex;//存放顶点
    protected int[][] edges;//存放边
    protected boolean[] isVisited;//是否被访问
    protected int numOfEdges;
    public Graph(int n) {
        this.vertex=new ArrayList<>(n);
        this.edges=new int[n][n];
        this.isVisited=new boolean[n];
    }

    //常用方法
    // 1. 获取节点个数
    protected int getNumOfVertex(){
        return vertex.size();
    }
    // 2. 打印邻接矩阵
    protected void printGraph(){
        System.out.print(" ");
        for (String s : vertex) System.out.print(" " + s);
        System.out.println();
        for(int r=0;r<vertex.size();r++){
            System.out.print(vertex.get(r) + " ");
            for(int c=0;c<vertex.size();c++) {
                System.out.print(edges[r][c]+" ");
            }
            System.out.println();
        }
    }
    // 3. 获取边的数目
    protected int getNumOfEdges(){
        return numOfEdges;
    }
    // 4. 获取某条边的权值
    protected int getWeightOfEdges(int v1,int v2){
        return edges[v1][v2];
    }
    // 5. 添加节点
    protected void addVertex(String v){
        vertex.add(v);
    }
    // 6. 添加边（双向）
    protected void addEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        numOfEdges++;
    }
    // 7.获取顶点索引对应的值
    protected String getValueByIndex(int i){
        return vertex.get(i);
    }

测试：

@Test
    public void testMethods(){
        Graph graph=new Graph(5);
        graph.addVertex("A");
        graph.addVertex("B");
        graph.addVertex("C");
        graph.addVertex("D");
        graph.addVertex("E");
        graph.addEdge(0,1,1);
        graph.addEdge(0,2,1);
        graph.addEdge(1,2,1);
        graph.addEdge(1,3,1);
        graph.addEdge(1,4,1);
        System.out.println("边的数量： "+graph.getNumOfEdges());
        System.out.println("顶点的数量： "+graph.getNumOfVertex());
        System.out.println("邻接矩阵：");
        graph.printGraph();
    }



边的数量： 5
顶点的数量： 5
邻接矩阵：
  A B C D E
A 0 1 1 0 0 
B 1 0 1 1 1 
C 1 1 0 0 0 
D 0 1 0 0 0 
E 0 1 0 0 0

4.2 图的深度优先搜索

深度优先搜索(Depth First Search)的思想：

深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点，可以这样理解：每次都在访问完 当前结点 后首先访问 当前结点的第一个邻接结点 。

我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。

显然，深度优先搜索是一个递归的过程

深度优先遍历算法步骤

访问初始结点 v ，并标记结点 v 为已访问。

查找结点 v 的第一个邻接结点 w 。

若 w 存在，则继续执行 4 ，如果 w 不存在，则回到第 1 步，将从 v 的下一个结点继续。

若 w 未被访问，对 w 进行深度优先遍历递归（即把 w 当做另一个 v ，然后进行步骤 123 ）。

查找结点 v 的 w 邻接结点的下一个邻接结点，转到步骤 3 。

//1.深度优先DFS
    protected void DFS(int index){
        //标记为已访问
        isVisited[index]=true;
        System.out.print(vertex.get(index)+" ");
        //从某点开始，找与之依次邻接的点
        for(int i=0;i<vertex.size();i++) {
            //如果都遍历过了就退出，防止无限循环
            if (!isVisited[i]) {
                //一旦找到邻接点，且其未被访问过，就对其进行深度优先搜索
                if (edges[index][i] != 0 && !isVisited[i]) {
                    DFS(i);
                }
                //如果找到最后都没找到合适的邻接点，就回溯到该点前面的点再次进行深度优先搜索
                if (i == vertex.size() - 1 && edges[index][i] == 0) DFS(i - 1);
            }
        }
    }

测试：

@Test
    public void testDFS(){
        Graph graph=new Graph(8);
        graph.addVertex("1");
        graph.addVertex("2");
        graph.addVertex("3");
        graph.addVertex("4");
        graph.addVertex("5");
        graph.addVertex("6");
        graph.addVertex("7");
        graph.addVertex("8");
        graph.addEdge(0, 1, 1);
        graph.addEdge(0, 2, 1);
        graph.addEdge(1, 3, 1);
        graph.addEdge(1, 4, 1);
        graph.addEdge(3, 7, 1);
        graph.addEdge(4, 7, 1);
        graph.addEdge(2, 5, 1);
        graph.addEdge(2, 6, 1);
        graph.addEdge(5, 6, 1);
        System.out.println("邻接矩阵：");
        graph.printGraph();
        System.out.println("深度优先搜索：");
        graph.DFS(0);
    }



邻接矩阵：
  1 2 3 4 5 6 7 8
1 0 1 1 0 0 0 0 0 
2 1 0 0 1 1 0 0 0 
3 1 0 0 0 0 1 1 0 
4 0 1 0 0 0 0 0 1 
5 0 1 0 0 0 0 0 1 
6 0 0 1 0 0 0 1 0 
7 0 0 1 0 0 1 0 0 
8 0 0 0 1 1 0 0 0 
深度优先搜索：
1 2 4 8 5 3 6 7

4.3 图的广度优先搜索

广度优先搜索(Broad First Search)的基本思想。

类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来访问这些结点的邻接结点

广度优先遍历算法步骤

访问初始结点 v 并标记结点 v 为已访问。

结点 v 入队列

当队列非空时，继续执行，否则算法结束。

出队列，取得队头结点 u 。

查找结点 u 的第一个邻接结点 w 。

若结点 u 的邻接结点 w 不存在，则转到步骤 3 ；否则循环执行以下三个步骤：

6.1 若结点w尚未被访问，则访问结点w并标记为已访问。

6.2 结点w入队列

6.3 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

//2.广度优先BFS
    protected void BFS() {
        int index=0;//当前进行广度搜索的顶点索引
        Queue<Integer> order = new LinkedList<>();//存储中间的遍历结果
        isVisited[index] = true;//标记为已访问
        order.add(index);
        System.out.print(vertex.get(index) + " ");

        //队列为空代表遍历完了
        while (!order.isEmpty()) {
            //从某点开始，找与之依次邻接的点
            for (int i = 0; i < vertex.size(); i++) {
                    //若找到了邻接点，且其未被访问过，就标记为已访问并入队，再接着找下一个邻接点
                    if (edges[index][i] != 0 && !isVisited[i]) {
                        isVisited[i] = true;
                        order.add(i);
                        System.out.print(vertex.get(i) + " ");
                    }
            }
            //如果某点的邻接点遍历完了，就从队列中取出一个顶点继续广度搜索
            index=order.poll();
        }
    }

测试：

@Test
    public void testBFS(){
        Graph graph=new Graph(8);
        graph.addVertex("1");
        graph.addVertex("2");
        graph.addVertex("3");
        graph.addVertex("4");
        graph.addVertex("5");
        graph.addVertex("6");
        graph.addVertex("7");
        graph.addVertex("8");
        graph.addEdge(0, 1, 1);
        graph.addEdge(0, 2, 1);
        graph.addEdge(1, 3, 1);
        graph.addEdge(1, 4, 1);
        graph.addEdge(3, 7, 1);
        graph.addEdge(4, 7, 1);
        graph.addEdge(2, 5, 1);
        graph.addEdge(2, 6, 1);
        graph.addEdge(5, 6, 1);
        System.out.println("邻接矩阵：");
        graph.printGraph();
        System.out.println("广度优先搜索：");
        graph.BFS();
    }



邻接矩阵：
  1 2 3 4 5 6 7 8
1 0 1 1 0 0 0 0 0 
2 1 0 0 1 1 0 0 0 
3 1 0 0 0 0 1 1 0 
4 0 1 0 0 0 0 0 1 
5 0 1 0 0 0 0 0 1 
6 0 0 1 0 0 0 1 0 
7 0 0 1 0 0 1 0 0 
8 0 0 0 1 1 0 0 0 
广度优先搜索：
1 2 3 4 5 6 7 8