一文了解图的内容

最新推荐文章于 2024-07-16 08:39:59 发布

ALin_Think

最新推荐文章于 2024-07-16 08:39:59 发布

阅读量221

点赞数 1

分类专栏：数据结构与算法文章标签：数据结构

本文链接：https://blog.csdn.net/ALin_Think/article/details/105171213

版权

数据结构与算法专栏收录该内容

34 篇文章 3 订阅

订阅专栏

文章目录

图

图的意义

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

基本介绍

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点。
1)顶点(vertex)
2)边(edge)
3)路径
4)无向图
5)有向图
6)带权图

无向图

无向图：顶点之间的连接没有方向，比如A-B,即可以是 A-> B 也可以 B->A .
路径，比如从D -> C的路径有
1、D->B->C
2、D->A->B->C

有向图

有向图：顶点之间的连接有方向，比如A-B,只能是 A-> B 不能是 B->A

带权图

带权图：这种边带权值的图也叫网.

表示方式

1、二维数组表示（邻接矩阵）
2、链表表示（邻接表）

领接矩阵

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1…n个点。
在这里插入图片描述

领接表

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

2、邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成
在这里插入图片描述

图的遍历

1、深度优先遍历
2、广度优先遍历

深度优先遍历(Depth First Search)

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

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

3、深度优先搜索是一个递归的过程

思路

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

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

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

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

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

过程

1、假如从A开始访问
2、A之后访问未访问的点，点B未被访问，所以访问B（这里从构造按添加的顺序ABCDE，如果ACBDE，就从C开始）
3、又以B为起点去访问未访问的点，B去访问A，但A已经访问，所以访问C
4、以C为起点去访问未访问的点，与C关联的点之前都被访问过，回退到B点
5、B开始访问D，D被访问
6、D没有可以访问的点，回退B
7、B开始访问E，E被访问，回退B
8、B没有可访问的，回退A
9、A没有可以访问的点，结束
10、至此，所有的点都被访问，访问顺序A-B-C-D-E
在这里插入图片描述

广度优先遍历(Broad First Search)

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

思路

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

2)结点v入队列

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

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

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

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

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

6.2 结点w入队列

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

过程

存在一个队列

1、先访问A，将A加入队列:[A]
2、访问A，A离开队列，之后访问B、C，B、C加入队列:[B、C]
3、在从B开始访问，访问D、E，所以B离开队列，D、E加入队列:[C、D、E]
4、在从C开始访问，C没有可访问的:[D、E]
5、在从D开始访问，D没有可访问的:[E]
6、在从E开始访问，E没有可访问的:[]
7、结束
在这里插入图片描述

代码

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class Graph {

    private ArrayList<String> vertexList; // 点的集合
    private int[][] edges; // 领接矩阵
    private int numOfEdges; // 边的数量
    private boolean[] isVisited;

    public static void main(String[] args) {
        int n = 5;
        String vertexs[] = {"A", "B", "C", "D", "E"};
        Graph graph = new Graph(n);
        for (String value : vertexs) {
            graph.insertVertex(value);
        }
        // A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.showGraph();

        System.out.println("DFS");
        graph.dfs();
        System.out.println();
        System.out.println("BFS");
        graph.bfs();
    }

    public Graph(int n) {
        // 初始化
        edges = new int[n][n];
        vertexList = new ArrayList<>(n);
        numOfEdges = 0;
        isVisited = new boolean[5];
    }

    // 得到第一个领接点的下标
    public int getFirstNeighbor(int index) {
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // 根据前一个领接结点的下标获取下一个领接结点
    public int getNextNeighbor(int v1, int v2) {
        for (int j = v2 + 1; j < vertexList.size(); j++) {
            if (edges[v1][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    // DFS
    public void dfs(boolean[] isVisited, int i) {
        System.out.print(getValueByIndex(i) + "->");
        isVisited[i] = true;
        int w = getFirstNeighbor(i);
        while (w != -1) {
            if (!isVisited[w]) {
                dfs(isVisited, w);
            }
            w = getNextNeighbor(i, w);
        }
    }

    // BFS
    public void bfs(boolean[] isVisited, int i) {
        int u;
        int w;
        // 队列
        LinkedList<Object> queue = new LinkedList<>();
        System.out.print(getValueByIndex(i) + "->");
        isVisited[i] = true;
        queue.addLast(i);
        while (!queue.isEmpty()) {
            u = (Integer) queue.removeFirst();
            w = getFirstNeighbor(u);
            while (w != -1) {
                if (!isVisited[w]) {
                    System.out.print(getValueByIndex(w) + "->");
                    isVisited[w] = true;
                    queue.addLast(w);
                }
                w = getNextNeighbor(u, w);
            }
        }
    }

    // BFS重载
    public void bfs() {
        isVisited = new boolean[5];
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                bfs(isVisited, i);
            }
        }
    }
    // DFS重载
    public void dfs() {
        isVisited = new boolean[5];
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

    // 返回边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    // 返回结点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    // 返回下标为i的结点
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

    // 返回权重
    public int getWeight(int v1, int v2) {
        return edges[v1][v2];
    }

    // 返回矩阵
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    // 插入结点
    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }

    // 添加边
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}