数据结构 - 图(深度优先与广度优先)

最新推荐文章于 2024-05-09 11:45:55 发布
最新推荐文章于 2024-05-09 11:45:55 发布
阅读量1.9k 收藏 6
点赞数 1
分类专栏： 数据结构 文章标签： java 数据结构 图论 深度搜索 广度搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sj15814963053/article/details/109992538
版权

文章目录

1.图基本介绍

为什么要有图？

前面我们学了线性表和树
线性表局限于一个直接前驱和一个直接后继的关系
树也只能有一个直接前驱也就是父节点。
当我们需要表示多对多的关系时,这里我们就用到了"图"。

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。如图：

image-20201122172349533

图的常用概念：

  • 顶点(vertex)
  • 边(edge)
image-20201122172557096
  • 路径：比如从 D -> C 的路径有
    • D->B->C
    • D->A->B->C
  • 无向图(上图)：顶点之间的连接没有方向，比如A-B,即可以是 A-> B 也可以 B->A .
  • 有向图：顶点之间的连接有方向，比如A-B，只能是 A-> B 不能是 B->A .
image-20201122172710247
  • 带权图：这种边带权值的图也叫网
image-20201122172825241

2.图的表示方式

图的表示方式有两种：

  • 二维数组表示（邻接矩阵）
  • 链表表示（邻接表）

2.1 邻接矩阵

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

2.2 邻接表

1.邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在的,会造成空间的一定损失.
2.邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由"数组+链表"组成
image-20201122185634299 
说明:
1.标号为0的结点的相关联的结点为 1,2,3,4
2.标号为1的结点的相关联结点为 0,4
3.标号为2的结点相关联的结点为 0,4,5
4.....

3.图的创建图解

要求: 代码实现如下图结构

image-20201122190236279

思路分析  
(1) 存储顶点String类型，使用ArrayList保存顶点
(2) 保存矩阵 int[][] edges

3.1 代码实现

/**
 * @author xiexu
 * @create 2020-11-22 7:19 下午
 */
public class Graph {

    ArrayList<String> vertexList; //存储顶点的集合
    int[][] edges; //存储图对应的邻接矩阵
    int numOfEdges; //表示边的数目

    public static void main(String[] args) {
        //测试一把图是否创建成功
        int n = 5; //节点的个数
        String Vertexs[] = {"A", "B", "C", "D", "E"};

        //创建图对象
        Graph graph = new Graph(5);
        //循环的添加顶点
        for (String vertex : Vertexs) {
            graph.insertVertex(vertex);
        }

        //添加边
        //A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1); // A-B
        graph.insertEdge(0, 2, 1); // A-C
        graph.insertEdge(1, 2, 1); // B-C
        graph.insertEdge(1, 3, 1); // B-D
        graph.insertEdge(1, 4, 1); // B-E

        //显示邻接矩阵
        graph.showGraph();
    }

    //构造器
    public Graph(int n) {
        // 初始化矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }

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

    /**
     * @param v1     表示点的下标即第几个顶点 "A"-"B" "A"->0 "B"->1
     * @param v2     表示第二个顶点对应的下标
     * @param weight 表示权值，1代表相关联，0表示不关联
     */
    //添加边
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

    //图中常用的方法
    // 返回节点的个数
    public int getNumber() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回节点i(下标)对应的数据：0->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

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

    //显示图对应的矩阵
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

}

程序执行结果

[0, 1, 1, 0, 0]
[1, 0, 1, 1, 1]
[1, 1, 0, 0, 0]
[0, 1, 0, 0, 0]
[0, 1, 0, 0, 0]

4.图的深度优先遍历(DFS)算法图解

图遍历介绍

  • 所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略

  • 一般有两种访问策略:

    • 深度优先遍历
    • 广度优先遍历

深度优先遍历基本思想

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

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

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

深度优先遍历算法步骤

1.访问初始结点v，并标记结点v为已访问。
2.查找结点v的第一个邻接结点w。
3.若w存在：
  3.1 如果w未被访问过，就把w当做下一个v，输出该w，然后标记w已被访问过，接着查找w的第一个邻接节点，继续执行深度遍历
  3.2 如果w已经被访问过，就以v为前驱节点，找到w后面的下一个邻接节点
  若w不存在：
  3.3 说明v真的没有下一个邻接节点了，已经到头了，我们回到w，继续以v为前驱节点，找到w后面的下一个邻接节点
4.经过如上步骤，图中可能还有其他顶点未被访问，继续从下一个顶点执行如上操作

如何找到当前顶点的下一个邻接点？
 假设当前正在遍历的顶点索引为 i ，顶点 i 的边信息存储在 edges[][]数组中第 i 行
 假设顶点 i 当前遍历到的邻接节点索引为 j ，即已经遍历到了 第 edges[i][j]处，需要从 edges[i][j]之后去找顶点 i 的下一个邻接点索引，也就是edges[i][j+1]

image-20201122190236279

举例说明

  • 访问顶点 A 后输出 A ，A 的第一个邻接节点是 B ，B 未被访问过，我们访问顶点 B

image-20200720163418025

  • 访问顶点 B 后输出 A–> B
    • B 的第一个邻接节点 A 已经被访问过了
    • B 的第二个邻接节点 C 还未被访问过，我们访问节点 C

image-20200720163837146

  • 访问节点 C
    • C 的第一个邻接节点是 A ，然而 A 已经访问过了
    • C 的下一个邻接节点是 B ，然而 B 也已经访问过了
    • 除此之外，C 再也没有其他邻接点
    • 我们回到顶点 B ，访问节点 B 的下一个邻接点：顶点 D

image-20200720163935313

  • 访问顶点 D 后输出 A --> B --> C --> D ，D 没有邻接节点，所以又返回到顶点 B ，访问顶点 B 的下一个邻接点：顶点 E
  • 访问顶点 E 后输出 A --> B --> C --> D --> E，E 没有邻接节点，所以又返回到顶点 B
  • B 的所有邻接点都访问过了，返回到顶点 A
  • 以上所有操作仅是一轮，还需要再对图中其他顶点进行以上操作

4.1 代码实现

/**
 * @author xiexu
 * @create 2020-11-22 7:19 下午
 */
public class Graph {

    ArrayList<String> vertexList; //存储顶点的集合
    int[][] edges; //存储图对应的邻接矩阵
    int numOfEdges; //表示边的数目
    // 定义一个数组boolean[], 记录某个节点是否被访问
    boolean[] isVisited;

    public static void main(String[] args) {
        //测试一把图是否创建成功
        int n = 5; //节点的个数
        String Vertexs[] = {"A", "B", "C", "D", "E"};

        //创建图对象
        Graph graph = new Graph(5);
        //循环的添加顶点
        for (String vertex : Vertexs) {
            graph.insertVertex(vertex);
        }

        //添加边
        //A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1); // A-B
        graph.insertEdge(0, 2, 1); // A-C
        graph.insertEdge(1, 2, 1); // B-C
        graph.insertEdge(1, 3, 1); // B-D
        graph.insertEdge(1, 4, 1); // B-E

        //显示邻接矩阵
        graph.showGraph();

        //测试一把，我们的dfs遍历是否ok
        System.out.println("深度遍历");
        graph.dfs();  // A->B->C->D->E
    }

    //构造器
    public Graph(int n) {
        // 初始化矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }

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

    /**
     * @param v1     表示点的下标即第几个顶点 "A"-"B" "A"->0 "B"->1
     * @param v2     表示第二个顶点对应的下标
     * @param weight 表示权值，1代表相关联，0表示不关联
     */
    //添加边
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

    //图中常用的方法
    // 返回节点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回节点i(下标)对应的数据：0->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

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

    //显示图对应的矩阵
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * index是行，指的是出发的节点
     * j 遍历的是列，指的是要到达的节点
     *
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-1
     */
    //得到第一个邻接节点的下标 w
    public int getFirstNeighbor(int index) {
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 如果w节点已经访问过，就继续查找下一个邻接节点
     *
     * @param v1 v1代表第v1行
     * @param v2 v2代表第v2列，并且v2是v1的邻接节点
     * @return
     */
    //根据前一个邻接节点的下标，获取下一个邻接节点
    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;
    }

    //深度优先遍历算法
    public void dfs(boolean[] isVisited, int i) {
        //首先我们访问该节点，并输出
        System.out.print(getValueByIndex(i) + "->");
        //将节点设置为已经访问过
        isVisited[i] = true;
        //查找节点i的第一个邻接节点w
        int w = getFirstNeighbor(i);
        while (w != -1) { //说明第一个邻接节点w是存在的
            //如果w节点未被访问过
            if (!isVisited[w]) { //isVisited[w]默认是false
                dfs(isVisited, w);
            }
            //如果w节点已经被访问过，就返回i节点查找下一个邻接节点
            w = getNextNeighbor(i, w);
        }
    }

    //对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
    public void dfs() {
        isVisited = new boolean[vertexList.size()];
        //遍历所有的节点，进行dfs[回溯]
        //getNumOfVertex()返回节点的个数
        for (int i = 0; i < getNumOfVertex(); i++) {
            //如果当前节点i没有被访问过，就进行dfs遍历
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

}

5.图的广度优先遍历(BFS)算法图解

广度优先遍历基本思想

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

广度优先遍历算法步骤

image-20201122190236279

1.访问初始结点v并标记结点v为已访问。
2.结点v入队列
3.当队列非空时，继续执行步骤4，否则算法结束。
4.出队列，取出队列的头结点u的下标。
5.查找结点u的第一个邻接结点w。
6.若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
	6.1 若结点w尚未被访问，则访问结点w并标记为已访问。 
	6.2 结点w入队列 
	6.3 以u为前驱节点，找到w后面的下一个邻接节点，并转到步骤6。

5.1 代码实现

/**
 * @author xiexu
 * @create 2020-11-22 7:19 下午
 */
public class Graph {

    ArrayList<String> vertexList; //存储顶点的集合
    int[][] edges; //存储图对应的邻接矩阵
    int numOfEdges; //表示边的数目
    // 定义一个数组boolean[], 记录某个节点是否被访问
    boolean[] isVisited;

    public static void main(String[] args) {
        //测试一把图是否创建成功
        int n = 5; //节点的个数
        String Vertexs[] = {"A", "B", "C", "D", "E"};

        //创建图对象
        Graph graph = new Graph(5);
        //循环的添加顶点
        for (String vertex : Vertexs) {
            graph.insertVertex(vertex);
        }

        //添加边
        //A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1); // A-B
        graph.insertEdge(0, 2, 1); // A-C
        graph.insertEdge(1, 2, 1); // B-C
        graph.insertEdge(1, 3, 1); // B-D
        graph.insertEdge(1, 4, 1); // B-E

        //显示邻接矩阵
        graph.showGraph();

        //测试一把，我们的dfs遍历是否ok
        System.out.println("深度遍历");
        graph.dfs();  // A->B->C->D->E

        System.out.println();

        System.out.println("广度遍历");
        graph.bfs();  // A->B->C->D->E
    }

    //构造器
    public Graph(int n) {
        // 初始化矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }

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

    /**
     * @param v1     表示点的下标即第几个顶点 "A"-"B" "A"->0 "B"->1
     * @param v2     表示第二个顶点对应的下标
     * @param weight 表示权值，1代表相关联，0表示不关联
     */
    //添加边
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

    //图中常用的方法
    // 返回节点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回节点i(下标)对应的数据：0->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

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

    //显示图对应的矩阵
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * index是行，指的是出发的节点
     * j 遍历的是列，指的是要到达的节点
     *
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-1
     */
    //得到第一个邻接节点的下标 w
    public int getFirstNeighbor(int index) {
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 如果w节点已经访问过，就继续查找下一个邻接节点
     *
     * @param v1 v1代表第v1行
     * @param v2 v2代表第v2列，并且v2是v1的邻接节点
     * @return
     */
    //根据前一个邻接节点的下标，获取下一个邻接节点
    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;
    }

    //深度优先遍历算法
    public void dfs(boolean[] isVisited, int i) {
        //首先我们访问该节点，并输出
        System.out.print(getValueByIndex(i) + "->");
        //将节点设置为已经访问过
        isVisited[i] = true;
        //查找节点i的第一个邻接节点w
        int w = getFirstNeighbor(i);
        while (w != -1) { //说明第一个邻接节点w是存在的
            //如果w节点未被访问过
            if (!isVisited[w]) { //isVisited[w]默认是false
                dfs(isVisited, w);
            }
            //如果w节点已经被访问过，就返回i节点查找下一个邻接节点
            w = getNextNeighbor(i, w);
        }
    }

    //对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
    public void dfs() {
        isVisited = new boolean[vertexList.size()];
        //遍历所有的节点，进行dfs[回溯]
        //getNumOfVertex()返回节点的个数
        for (int i = 0; i < getNumOfVertex(); i++) {
            //如果当前节点i没有被访问过，就进行dfs遍历
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

    //对一个节点进行广度优先遍历的方法
    public void bfs(boolean[] isVisited, int i) {
        int u; //表示队列的头结点对应的下标
        int w; //邻接节点w
        //队列，记录节点访问的顺序
        LinkedList<Integer> queue = new LinkedList<>();
        //访问节点，输出节点的信息
        System.out.print(getValueByIndex(i) + "->");
        //标记为已访问
        isVisited[i] = true;
        //将节点加入队列
        queue.addLast(i);

        while (!queue.isEmpty()) {
            //取出队列的头结点的下标
            u = queue.removeFirst();
            //得到第一个邻接节点的下标w
            w = getFirstNeighbor(u);
            while (w != -1) { //找到第一个邻接节点
                //判断w是否被访问过
                if (!isVisited[w]) { //isVisited[w]默认为false
                    System.out.print(getValueByIndex(w) + "->");
                    //标记w被访问过
                    isVisited[w] = true;
                    //将w入队列
                    queue.addLast(w);
                }
                //以u为前驱节点，找到w后面的下一个邻接节点
                w = getNextNeighbor(u, w);
            }
        }
    }

    //遍历所有的节点，都进行广度优先搜索
    public void bfs() {
        isVisited = new boolean[vertexList.size()];
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                bfs(isVisited, i);
            }
        }
    }

}

6.图的深度优先 VS 广度优先

image-20201123114549794

graph.insertEdge(0, 1, 1);
graph.insertEdge(0, 2, 1);
graph.insertEdge(1, 3, 1);
graph.insertEdge(1, 4, 1);
graph.insertEdge(3, 7, 1);
graph.insertEdge(4, 7, 1);
graph.insertEdge(2, 5, 1);
graph.insertEdge(2, 6, 1);
graph.insertEdge(5, 6, 1);

深度优先遍历顺序为 1->2->4->8->5->3->6->7
广度优先算法的遍历顺序为 1->2->3->4->5->6->7->8 

/**
 * @author xiexu
 * @create 2020-11-22 7:19 下午
 */
public class Graph {

    ArrayList<String> vertexList; //存储顶点的集合
    int[][] edges; //存储图对应的邻接矩阵
    int numOfEdges; //表示边的数目
    // 定义一个数组boolean[], 记录某个节点是否被访问
    boolean[] isVisited;

    public static void main(String[] args) {
        //测试一把图是否创建成功
        int n = 5; //节点的个数
        String Vertexs[] = {"1", "2", "3", "4", "5", "6", "7", "8"};

        //创建图对象
        Graph graph = new Graph(8);
        //循环的添加顶点
        for (String vertex : Vertexs) {
            graph.insertVertex(vertex);
        }

        //添加边
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);

        //显示邻接矩阵
        graph.showGraph();

        //测试一把，我们的dfs遍历是否ok
        System.out.println("深度遍历");
        graph.dfs();  // A->B->C->D->E

        System.out.println();

        System.out.println("广度遍历");
        graph.bfs();  // A->B->C->D->E
    }

    //构造器
    public Graph(int n) {
        // 初始化矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }

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

    /**
     * @param v1     表示点的下标即第几个顶点 "A"-"B" "A"->0 "B"->1
     * @param v2     表示第二个顶点对应的下标
     * @param weight 表示权值，1代表相关联，0表示不关联
     */
    //添加边
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

    //图中常用的方法
    // 返回节点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回节点i(下标)对应的数据：0->"A" 1->"B" 2->"C"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

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

    //显示图对应的矩阵
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * index是行，指的是出发的节点
     * j 遍历的是列，指的是要到达的节点
     *
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-1
     */
    //得到第一个邻接节点的下标 w
    public int getFirstNeighbor(int index) {
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 如果w节点已经访问过，就继续查找下一个邻接节点
     *
     * @param v1 v1代表第v1行
     * @param v2 v2代表第v2列，并且v2是v1的邻接节点
     * @return
     */
    //根据前一个邻接节点的下标，获取下一个邻接节点
    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;
    }

    //深度优先遍历算法
    public void dfs(boolean[] isVisited, int i) {
        //首先我们访问该节点，并输出
        System.out.print(getValueByIndex(i) + "->");
        //将节点设置为已经访问过
        isVisited[i] = true;
        //查找节点i的第一个邻接节点w
        int w = getFirstNeighbor(i);
        while (w != -1) { //说明第一个邻接节点w是存在的
            //如果w节点未被访问过
            if (!isVisited[w]) { //isVisited[w]默认是false
                dfs(isVisited, w);
            }
            //如果w节点已经被访问过，就以v为前驱节点，找到w后面的下一个邻接节点
            w = getNextNeighbor(i, w);
        }
    }

    //对dfs 进行一个重载, 遍历我们所有的结点，并进行 dfs
    public void dfs() {
        isVisited = new boolean[vertexList.size()];
        //遍历所有的节点，进行dfs[回溯]
        //getNumOfVertex()返回节点的个数
        for (int i = 0; i < getNumOfVertex(); i++) {
            //如果当前节点i没有被访问过，就进行dfs遍历
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

    //对一个节点进行广度优先遍历的方法
    public void bfs(boolean[] isVisited, int i) {
        int u; //表示队列的头结点对应的下标
        int w; //邻接节点w
        //队列，记录节点访问的顺序
        LinkedList<Integer> queue = new LinkedList<>();
        //访问节点，输出节点的信息
        System.out.print(getValueByIndex(i) + "->");
        //标记为已访问
        isVisited[i] = true;
        //将节点加入队列
        queue.addLast(i);

        while (!queue.isEmpty()) {
            //取出队列的头结点的下标
            u = queue.removeFirst();
            //得到第一个邻接节点的下标w
            w = getFirstNeighbor(u);
            while (w != -1) { //找到第一个邻接节点
                //判断w是否被访问过
                if (!isVisited[w]) { //isVisited[w]默认为false
                    System.out.print(getValueByIndex(w) + "->");
                    //标记w被访问过
                    isVisited[w] = true;
                    //将w入队列
                    queue.addLast(w);
                }
                //以u为前驱节点，找到w后面的下一个邻接节点
                w = getNextNeighbor(u, w);
            }
        }
    }

    //遍历所有的节点，都进行广度优先搜索
    public void bfs() {
        isVisited = new boolean[vertexList.size()];
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                bfs(isVisited, i);
            }
        }
    }

}

程序运行结果

[0, 1, 1, 0, 0, 0, 0, 0]
[1, 0, 0, 1, 1, 0, 0, 0]
[1, 0, 0, 0, 0, 1, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 1, 0]
[0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0]
深度遍历
1->2->4->8->5->3->6->7->
广度遍历
1->2->3->4->5->6->7->8->
猿小羽
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
假设图中数据元素类型是字符型，请采用邻接矩阵或邻接表实现图的以下基本操作： （1）构造图（包括有向图、有向网、无向图、无向网）； （2）根据深度优先遍历图。
06-09
1、图和网的区别：网是带权值的图 有向和无向的区别：有向直接标出谁指向谁，无向是有向的特例，有弧，说明也有弧。 构图： ①　确定顶点数，弧数，是否有权值 ②　输入每个顶点，弧，权值 ③　若是无向，则需实现弧与的同置 2、图的深度优先搜索遍历类似于树的先根遍历，沿着初始顶点出发的一条路径，尽可能深入地前进，直到所有顶点被访问完；用visited[]来存储顶点的访问情况，初始时所有顶点皆为未访问FALSE，访问一个顶点之后就被标记为已访问TRUE。
【数据结构——图】
weixin_64993156的博客
03-20 371
邻接矩阵和邻接表的序列不同所以访问的时候，他所需要是的时间就不相同，邻接矩阵在访问结点的时候需要遍历所有的结点，遍历所有邻接的边的时候也是需要遍历所有的结点，邻接表遍历结点的时候是遍历所有结点，图的基本概念，图的存储邻接矩阵，邻接表和十字链表，图的存储邻接多重表，图的重要操作，图的广度优先遍历，图的深度优先遍历 图的基本应用： 最小生成树，最短路径问题BFS算法，Dijkstra算法和Floyd算法，有向无环图描述表达式和拓扑排序：找到做事情得先后顺序以及关键路径
图的遍历（深度优先和广度优先）
最新发布
2302_77758423的博客
05-09 1634
相比于树结构的遍历，图的遍历要复杂得多，因为图中的任何一个节点都可能与其它所有节点相邻接。这就意味着，在访问了某个节点之后，可能会顺着某条路径再次返回到这个节点。为了防止对节点进行重复访问，在图的遍历过程中需要记录下已经访问过的节点。深度优先搜索（DFS）和广度优先搜索（BFS）是两种基本的图遍历方法。DFS更适合深入挖掘问题的解决方案，而BFS则适用于逐层分析问题，寻找最短路径或按层次顺序进行操作。
Java数据结构与算法 day12 图
杨丙寅
06-14 894
文章目录第12章 图图的基本介绍和存储形式图基本介绍图的表示方式图的创建图解和代码实现图的深度优先(DFS)算法图解与实现图的广度优先(BFS)算法图解图的DFS和BFS比较本章思维导图 第12章 图 本章源码：https://github.com/name365/Java-Data-structure 图的基本介绍和存储形式 图基本介绍 为什么要有图??? 前面我们学了线性表和树,线性表局限于一个直接前驱和一个直接后继的关系,树也只能有一个直接前驱也就是父节点。当我们需要表示多对多的关系时,这里我
图的遍历之 深度优先搜索和广度优先搜索
Lamb的博客
08-09 2447
它的思想是：从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。在第1步访问A之后，接下来应该访问的是A的邻接点，即"C,D,F"中的一个。
【基础知识】一文看懂深度优先算法和广度优先算法
fumeidonga的博客
06-08 9187
先上个图现在我们要访问图中的每个节点，即图的遍历。图的遍历是指，从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历。我们根据访问节点的顺序与方式（根据搜索方法），可以分为广度优先（BFS）和深度优先（DFS），这是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等。我们分别来介绍。
数据结构学习笔记——图的遍历算法（深度优先搜索和广度优先搜索）
小宇y的博客
08-18 3万+
若通过邻接表表示图，则每个顶点都入队一次，即所需时间为O(|V|)，搜索顶点的邻接顶点所需时间为O(|E|)，其时间复杂度为O(|V|+|E|)。若通过邻接表表示图，则查找所有顶点的邻接顶点所需时间为O(|E|)，访问顶点所需时间为O(|V|)，即总时间复杂度为O(|V|+|E|)。4、查看V7单链表，其邻接顶点为2，即V3，它已经被访问过，于是回到V3单链表，搜索下一个未被访问的邻接顶点；11、查看V8单链表，其邻接顶点为4，即V5，已经被访问过，于是回到V5单链表，搜索下一个未被访问的邻接顶点；....
python数据结构之图深度优先和广度优先实例详解
09-21
本文将深入探讨图的两种遍历方法：深度优先搜索（DFS，Depth-First Search）和广度优先搜索（BFS，Breadth-First Search），并提供Python代码实现。 首先，我们要理解什么是图。在数据结构中，图是由顶点（也称为...
数据结构课程设计-图的广度优先遍历.doc
11-29
"数据结构课程设计-图的广度优先遍历" 知识点一：图的广度优先遍历 * 图的广度优先遍历是从图中某个顶点出发，沿着某条搜索路径对图中其余每个顶点进行访问，并且使图中的每个顶点仅被访问一次的过程。 * 广度优先...
Python数据结构与算法之图的广度优先与深度优先搜索算法示例
09-20
主要介绍了Python数据结构与算法之图的广度优先与深度优先搜索算法,结合实例形式分析了图的广度优先与深度优先搜索算法原理与相关实现技巧,需要的朋友可以参考下
数据结构之图的表示、深度优先和广度优先遍历.zip
06-21
在这个"数据结构之图的表示、深度优先和广度优先遍历.zip"压缩包中，我们重点探讨的是图这一重要的数据结构，以及如何通过邻接矩阵和邻接表来表示它，以及如何进行深度优先遍历（DFS）和广度优先遍历（BFS）。...
【图论】图的深度优先遍历与广度优先遍历（图文讲解）
qq_49688477的博客
07-24 1万+
一、前言 看懂这篇博客你需要提前知道这些知识点 1.C++链式前向星存图； 2.dfs和bfs是什么以及基本概念； 3.C++STL中的queue，队列数据结构的简单知识点； 4.有关图的一些简单的概念； 图论是一个很重要的知识块，在学习如何遍历图之前，我们首先当然得知道要怎样去建图。在下面的内容里，我们将使用链式前向星来建图，如果对建图有什么问题的话可以移步这篇博客来学习。 链式前向星 在了解建图的方法后，我们当然要开始考虑如何遍历图中的每一个点，在这里，我们将使用两种最基础的遍历方式-----深度优先搜
图的广度优先搜索和深度优先搜索
24考研人晴落的博客
10-27 5315
图的广度优先搜索和深度优先搜索，BFS和DFS的算法思路、分析、代码、应用，遍历的生成树、生成森林问题。
大话数据结构-图的深度优先遍历和广度优先遍历
村长Korbin
03-02 9906
数据结构中图的深度优先遍历、广度优先遍历定义，邻接矩阵、邻接表、逆邻接表、十字链表、邻接多重表和边集数组的深度优先遍历实现和广度优先遍历实现。
图的广度优先搜索（BFS）和深度优先搜索（DFS）算法解析
热门推荐
weixin_40953222的博客
06-02 16万+
BFS/DFS算法解析【算法入门]2018/6/21.前言和树的遍历类似，图的遍历也是从图中某点出发，然后按照某种方法对图中所有顶点进行访问，且仅访问一次。但是图的遍历相对树而言要更为复杂。因为图中的任意顶点都可能与其他顶点相邻，所以在图的遍历中必须记录已被访问的顶点，避免重复访问。根据搜索路径的不同，我们可以将遍历图的方法分为两种：广度优先搜索和深度优先搜索。2.图的基本概念2.1.无向图和无向...
大话数据结构---（六）图的深度优先遍历和广度优先遍历
松落
03-30 1万+
我们已经掌握了如何存储图中的信息，即邻接矩阵，邻接表，十字链表等。那么我们该如何利用这些存储结构中的数据呢，或者说我该如何找到我想要的数据呢，这里我们就得学会如何遍历图结构，而接下来会和大家介绍两种常用的遍历方法，深度优先遍历和广度优先遍历。
广度优先搜索算法带图详解
m0_54615144的博客
07-27 1万+
常常我们有这样一个问题，从一个起点开始要到一个终点，我们要找寻一条最短的路径，从图2-1举例，如果我们要求V0到V6的一条最短路（假设走一个节点按一步来算）
数据结构 - 图 （图的深度优先和广度优先）
方亚军的博客
03-07 2919
图的基本介绍 为什么要有图这种数据结构 数据结构有线性表和树 线性表局限与一个直接前驱和一个直接后继的关系 树也只能右一个直接前驱也就是父节点 当我们需要表示多对多的关系时，这里我们就需要用到图这种数据结构 图是一种数据结构，其中节点可以具有零个或者多个相邻的元素。2个节点之间的连接称为边。节点也可以称为顶点。 如图： 图的常用概念 1. 顶点（vertex） 2. 边（edge） 3....
【数据结构】图的遍历：广度优先（BFS），深度优先（DFS）
小人物，大梦想！
09-21 4728
算法思想，广度优先生成树，深度优先生成树，算法实现
图的遍历：深度优先与广度优先搜索
在计算机科学中，图是一种重要的数据结构，它可以用来表示对象之间的关系，如社交网络中的朋友关系、道路网络中的连接等。图由顶点（或节点）和边（连接顶点的线）组成，具有广泛的应用场景，包括网络路由、图像处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿小羽

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值