数据结构（五）——图的深度、广度遍历（java代码实现）

最新推荐文章于 2022-06-17 11:08:36 发布
最新推荐文章于 2022-06-17 11:08:36 发布
阅读量803 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45473439/article/details/119494149
版权

图

基本介绍

什么时候用到图

1)前面我们学了线性表和树

2)线性表局限于一个直接前驱和一个直接后继的关系3)树也只能有一个直接前驱也就是父节点

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

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

image-20210806152838724

图的常用概念

  1. 顶点 A、B、C、D、E、都是顶点
  2. 边 A-B就是一条边
  3. 路径: 比如从D->c的路径 有 D->B->C 或 D->A->B->C
  4. 无向图：顶点之间的连接没有方向如 A-B 即可以是A -> B 也可以是 B - > A

image-20210806153109957

  1. 有向图 （如下图 :顶点之间的连接有方向，比如A-B，只能是A->B 不能是 B -> A）

  2. 带权图（这种带权值的图也叫做网。）

    image-20210806153447998image-20210806153458213

图的表示方式

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

邻接矩阵

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

image-20210806162432846

邻接表

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

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

  3. 举例说明

image-20210806162658562

图快速入门

用邻接矩阵来保存图

package Graph;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author lixiangxiang
 * @description
 * @date 2021/8/6 16:49
 */
public class Graph {

    /** 边 */
    private int[][] edges;
    /**
     * 边数
     */
    private int numOfEdges;
    /**
     * 顶点集合
     */
    private List<String> vertexList;

    public static void main(String[] args) {
        int n = 8;  //结点的个数
        String vertexs[] = {"A", "B", "C", "D", "E"};
        
        //创建图对象
        Graph graph = new Graph(vertexs.length);
        //循环的添加顶点
        for(String vertex: vertexs) {
            graph.addVertex(vertex);
        }

        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();
    }

    /**
     * 添加顶点
     */
    public void addVertex(String vertex) {
        vertexList.add(vertex);
    }

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

    }

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

    /**
     * 根据下标获取数据
     * @param i
     * @return
     */
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

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

图的深度优先遍历

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略: (1)深度优先遍历 (2)广度优先遍历

深度优先遍历基本思想

图的深度优先搜索(Depth First Search) 。

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

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

  3.  显然，深度优先搜索是一个递归的过程
深度优先遍历算法步骤

  1. 输出v节点，并设置已访问

  2. 依次检查邻接矩阵 第v 行 有没有没被访问的节点， 值!=0 且 visited = false

  3. 当检测到未被访问的节点时，以w为初始节点进行递归。

package Graph;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author lixiangxiang
 * @description
 * @date 2021/8/6 16:49
 */
public class Graph {

    /** 边 */
    private int[][] edges;
    /**
     * 边数
     */
    private int numOfEdges;
    /**
     * 顶点集合
     */
    private List<String> vertexList;

    /**
     * 记录是否被访问过
     */
    private boolean[] isVisit;

    public static void main(String[] args) {
        int n = 8;  //结点的个数
        String vertexs[] = {"A", "B", "C", "D", "E"};

        //创建图对象
        Graph graph = new Graph(vertexs.length);
        //循环的添加顶点
        for(String vertex: vertexs) {
            graph.addVertex(vertex);
        }
		//添加边
        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();
     
        //深度遍历
		graph.DFS(0);

    }

    /**
     * 添加顶点
     */
    public void addVertex(String vertex) {
        vertexList.add(vertex);
    }

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

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

    /**
     * 根据下标获取数据
     * @param i
     * @return
     */
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

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



     /**
     * description:
     *
     * @author: lixiangxiang
     * @param index 初始被访问的节点
     * @return void
     * @date 2021/8/7 16:30
     */
    public void DFS(int index) {
        //输出当前节点
        System.out.print(getValueByIndex(index)+"->");
        //设置为已访问
        isVisit[index] = true;
        //依次检查邻接矩阵 index所在的行有没有没被访问的节点，(每行 index之前的节点其实都已经被访问过，我们无需再检查)
        for (int w = index+1; w < edges[index].length; w++) {
            //如果下标为w的节点未被访问，递归调用DFS
            if (edges[index][w]!=0 && !isVisit[w]) {
                DFS(w);
            }
        }
    }
    
   
}
DFS 算法效率分析

用邻接矩阵来表示图，遍历图每一个顶点都要从头扫描该顶点所在行，时间复杂度O(n2)

用邻接表来表示图，虽然有2e个表节点，但只需扫描e个节点即可完成遍历，加上访问n个头节点的时间，时间复杂度为O(n+e)

  • 稠密图适用于在邻接矩阵上进行深度遍历
  • 稀疏图使用与在邻接表上进行深度遍历。
非连通图的遍历

从一个节点进行深度优先遍历后，再判断哪些顶点仍未被遍历到，从这些顶点开始再继续遍历

/**
     * description: 处理无向图问题
     *
     * @author: lixiangxiang
     * @param index 开始节点
     * @return void
     * @date 2021/8/7 17:11
  */
public void unConnectDFS(int index) {
        //按给定开始节点进行深度优先遍历
        DFS(index);
        //对所有没有遍历过的节点再次进行DFS搜索。
        for (int i = 0; i < vertexList.size(); i++) {
            if (!isVisit[i]) {
                DFS(i);
            }
        }
 }

图的广度优先遍历

思路:

从图的某一结点出发，首先依次访问该结点的所有邻接姐点Vi, Vi2,… Vi,再按这些顶点被访问的先后次序依次访问与它们相邻接的所有未被访问的顶点

重复此过程，直至所有顶点均被访问为止

image-20210807172011328

image-20210807183001526

使用链表储存图，并实现广度优先遍历

链表储存图的思路：(如上图所示)

  1. 以图的每个顶点为根节点创建链表
  2. 将每个顶点所连接的顶点储存到链表中。
  3. 图中储存所有的链表

广度优先遍历的思路

  1. 先输出第一个顶点，并标记已访问，将顶点放入队列中
  2. 如果队列不为空则进行循环
  3. 循环体内容：将对头元素出对，获取到对应链表
  4. 遍历链表获取到链表中第一个未被访问过的邻接节点
  5. 如果找到将其放入队列中，如果没有未被访问的节点则进行下一轮循环。
代码
package Graph;

import queue.CircleQueue;


/**
 * @author lixiangxiang
 * @description 用链表来储存图
 * @date 2021/8/7 18:31
 */
public class LinkedGraphDemo {

    public static void main(String[] args) {

        String vertexs[] = {"A", "B", "C", "D", "E"};
        LinkedGraph graph = new LinkedGraph(vertexs.length);
        //初始化每条链表的根节点。
        for (int i = 0; i < vertexs.length; i++) {
            graph.linkedLists[i].root = new RootNode(vertexs[i]);
        }
        graph.vertexs = vertexs;
        graph.linkedLists[0].addNode(3,vertexs[3]);
        graph.linkedLists[0].addNode(1,vertexs[1]);
        graph.linkedLists[1].addNode(4,vertexs[4]);
        graph.linkedLists[1].addNode(2,vertexs[2]);
        graph.linkedLists[1].addNode(0,vertexs[0]);
        graph.linkedLists[2].addNode(4,vertexs[4]);
        graph.linkedLists[2].addNode(3,vertexs[3]);
        graph.linkedLists[2].addNode(1,vertexs[1]);
        graph.linkedLists[3].addNode(2,vertexs[2]);
        graph.linkedLists[3].addNode(0,vertexs[0]);
        graph.linkedLists[4].addNode(2,vertexs[2]);
        graph.linkedLists[4].addNode(1,vertexs[1]);
//        graph.linkedLists[0].show();
        graph.show();

        graph.BFS(1);
    }


}



class LinkedGraph {

    LinkedGraph linkedGraph = new LinkedGraph(1);
    //图的邻接表。
    GraphLinkedList[] linkedLists;

    boolean[] visited;
    //图的当前顶点数
    int vexNum;

    //记录图的顶点
    String[] vertexs;


    //初始化
    public LinkedGraph(int vexNum) {
        this.vexNum = vexNum;
        linkedLists = new GraphLinkedList[vexNum];
        for (int i = 0; i < linkedLists.length; i++) {
            linkedLists[i] = new GraphLinkedList();
        }
        visited = new boolean[vexNum];
    }

    public void show() {
        for (int i = 0; i < linkedLists.length; i++) {
            linkedLists[i].show();
            System.out.println();
        }
    }

    /**
     * description:
     *
     * @author: lixiangxiang
     * @param v 开始节点下标
     * @return void
     * @date 2021/8/8 20:27
     */
    public void BFS(int v) {
         //输出当前节点
        System.out.print(vertexs[v]+"->");
        //标记当前节点已访问
        visited[v] = true;
        //创建一个队列
        CircleQueue queue= new CircleQueue(vexNum);
//        ArrayQueue<Integer> queue1 = new ArrayQueue<>(vexNum);
        //进队
        queue.addQueue(v);
        //如果队列不为空，
        while (!queue.isEmpety()) {
            //队头元素出队，
            int i = queue.getQueue();
            //获取对头元素对应的队列
            GraphLinkedList linkedList = linkedLists[i];
            //遍历获取其第一个未被访问的节点。
            Node node = getNextUnvisitedValue(linkedList,visited);
            //如果找到，w进队列
            if (node != null) {
                //输出该节点
                System.out.print(node.name + "->");
                //标记已访问
                visited[node.data] = true;
                //w 进队列
                queue.addQueue(node.data);
            }
        }
    }

    /**
     * description: 获取该链表中第一个未被访问的节点。
     *
     * @author: lixiangxiang
     * @param linkedList 需要查询的链表
     * @param visited 是否被访问过。
     * @return Graph.Node
     * @date 2021/8/8 21:43
     */
    public Node getNextUnvisitedValue(GraphLinkedList linkedList,boolean[] visited) {
        if (linkedList.root.next == null) {
            return null;
        }
        Node cur = linkedList.root.next;
        while (cur != null) {
            if (!visited[cur.data]) {
                return cur;
            }
            cur = cur.next;
        }
        return null;
    }
}


class GraphLinkedList {
    RootNode root;


    public void addNode(int value,String name) {
        Node newNode = new Node(value,name);
        if (root.next == null) {
            root.next = newNode;
            return;
        }
        Node cur = root.next;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = newNode;
    }



    public void show() {
        System.out.print(root.data+"->");
        Node cur = root.next;
        while (cur != null) {
            System.out.print(cur.data + "->");
            cur = cur.next;
        }
    }
}

/**
 * 顶点信息
 */
class Node {
    /**
     * 顶点值
     */
    int  data;

    /**
     * 下一节点
     */
    Node next;

    /**
     * 节点名
     */
    String name;

    /**
     * 其根节点
     */
    RootNode rootNode;

    public Node(int value,String name) {
        data = value;
       this.name = name;
    }
}

class RootNode {
    /**
     * 顶点值
     */
    String  data;

    /**
     * 下一节点
     */
    Node next;

    public RootNode(String value) {
        data = value;
    }
}

package queue;

import org.omg.CORBA.PRIVATE_MEMBER;

/**
 * @author lixiangxiang
 * @description 环形队列
 * @date 2021/4/18 9:14
 */
public class CircleQueue {
    //指向队列第一个数
    private int front;
    //队列尾部
    private int rear;
    //队列的大小
    private int maxSize;
    //数组大小
    private int arrSize;
    //模拟队列的数组
    private int[] queueArr;

    /**
     * 初始化
     */
    public CircleQueue(int size) {
        front = 0;
        rear = 0;
        maxSize = size ;
        arrSize = size + 1;
        queueArr = new int[arrSize];
    }

    /**
     * 判断队列是否为空
     */
    public boolean isEmpety () {
        return front == rear;
    }

    /**
     * 队列是否满
     */
    public boolean isFull () {
        return size() >= maxSize ;
    }

    /**
     * 有效数据的个数
     */
    public int size() {
        return (rear+arrSize-front) % (arrSize);
    }

    /**
     * 向队列中添加数据
     */
    public void addQueue (int data) {
        if (isFull()) {
            System.out.println("队列已满");
            return;
        }
        queueArr[rear] = data;
        rear = (rear + 1)%arrSize;
     }

    /**
     * 取出队列数据
     */
    public int getQueue () {
        if (isEmpety()) {
            throw new RuntimeException("队列为空");
        }
        int arr = queueArr[front] ;
        front = (front + 1)%arrSize;
        return arr;
    }

    /**
     * 获取头数据
     */
    public int headQueue () {
        if (isEmpety()) {
            throw new RuntimeException("队列为空");
        }
        return queueArr[front];
    }

    /**
     * 显示队列数据
     */
    public void show () {
        if (isEmpety()) {
            System.out.println("队列为空");
            return;
        }
        for (int i = front ; i < front + size() ; i++) {
            System.out.println("arr["+i%(maxSize)+"]="+queueArr[i%(arrSize)]);
        }
    }

}
邻接矩阵储存图实现广度优先遍历
package Graph;

import com.sun.jmx.remote.internal.ArrayQueue;
import queue.CircleQueue;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @author lixiangxiang
 * @description
 * @date 2021/8/6 16:49
 */
public class Graph {

    /**
     * 边
     */
    private int[][] edges;
    /**
     * 边数
     */
    private int numOfEdges;
    /**
     * 顶点集合
     */
    private List<String> vertexList;

    /**
     * 记录是否被访问过
     */
    private boolean[] isVisit;

    public static void main(String[] args) {
        int n = 8;  //结点的个数
//        String vertexs[] = {"A", "B", "C", "D", "E"};
        String vertexs[] = {"1", "2", "3", "4", "5", "6", "7", "8"};

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

//        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();
        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
//		graph.unConnectDFS(0); 
        //广度优先遍历 结果:1->2->3->4->5->6->7->8
        graph.BFS(0);
    }

    /**
     * 添加顶点
     */
    public void addVertex(String vertex) {
        vertexList.add(vertex);
    }

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


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

    /**
     * 根据下标获取数据
     *
     * @param i
     * @return
     */
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

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


    /**
     * description:
     *
     * @param index 初始被访问的节点
     * @return void
     * @author: lixiangxiang
     * @date 2021/8/7 16:30
     */
    public void DFS(int index) {
        //输出当前节点
        System.out.print(getValueByIndex(index) + "->");
        //设置为已访问
        isVisit[index] = true;
        //依次检查邻接矩阵 index所在的行有没有没被访问的邻接节点
        for (int w = 0; w < edges[index].length; w++) {
            //如果下标为w的节点未被访问，递归调用DFS
            if (edges[index][w] != 0 && !isVisit[w]) {
                DFS(w);
            }
        }
    }

     /**
     * description: 处理非连通图问题
     *
     * @param index 开始节点下标
     * @return void
     * @author: lixiangxiang
     * @date 2021/8/7 17:11
     */
    public void unConnectDFS(int index) {
        //按给定开始节点进行深度优先遍历
        DFS(index);
        //对所有没有遍历过的节点再次进行DFS搜索。
        for (int i = 0; i < vertexList.size(); i++) {
            if (!isVisit[i]) {
                DFS(i);
            }
        }
    }
    
    /**
     * description: 连通图的广度优先遍历
     *
     * @author: lixiangxiang
     * @param index 开始节点下标
     * @return void
     * @date 2021/8/9 9:15
     */
    public void BFS(int index) {
        //输出当前节点
        System.out.print(getValueByIndex(index) + "->");
        //设置为已访问
        isVisit[index] = true;
        //新建队列
        CircleQueue queue = new CircleQueue(vertexList.size());
        //将访问过的节点加入队列
        queue.addQueue(index);
        //如果队列不为空
        while (!queue.isEmpety()) {
            //取出队头元素
            int i = queue.getQueue();
            //寻找其下一个未访问过的邻接顶点
            for (int w = 0; w < edges[i].length; w++) {
                //找到下一个未访问过的邻接节点
                if (edges[i][w] != 0 && !isVisit[w]) {
                    //打印该节点
                    System.out.print(getValueByIndex(w) + "->");
                    //设置该节点已读
                    isVisit[w] = true;
                    //将该节点加入队列
                    queue.addQueue(w);
                }
            }
        }
    }

   
}
快乐是你的与我无关了
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的广度优先遍历和深度优先遍历Java语言实现
CSDN 精品推荐
11-19 232
文章目录一、图的遍历方法二、代码测试 一、图的遍历方法 1、深度优先遍历： 1.利用递归操作 2.首先定义一个visit数组，数组长度为节点个数，作用为判断每个节点是否访问过，在递归过程中，一但该节点访问过，就置为1 3.将visit数组所有元素置为0，表示还无元素被访问过 4.将每一个节点都作为开始点进行一次DFS操作，因为如果改图不是连通图，不能通过一次DFS访问所有节点，所以进行循环，将每个节点作为开始，进行一次DFS 5.从第一个节点开始，只要他的邻接节点没有被访问过，就一直继续访问，直到不能够走
数据结构C语言：图的深度广度遍历
m0_67231135的博客
06-01 1332
图的深度及广度遍历
(超详细)C++图的深度优先遍历、广度优先遍历（数据结构）
热门推荐
m0_54158068的博客
04-18 1万+
(超详细)C++图的深度优先遍历、广度优先遍历（数据结构）。根据下图，编写代码实现图的深度优先遍历和广度优先遍历。按照英文字母顺序，以邻接表为存储结构，实现图的深度优先和广度优先遍历。遍历的顺序从顶点a开始。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列。
【数据结构】图的深度遍历与广度遍历
流星雨的博客
03-23 6956
图是一种常见的数据格式，它的遍历主要分为两种： 深度优先遍历(DFS):类似于二叉树的前序前序遍历 广度优先遍历(BFS):类似于二叉树的层次遍历 一、出度与入度 在讲图的遍历之前，我们需要先了解图的数据结构。 对于图，我们一般定义横向是出度，纵向是入度。比如对于左图我们转成领接矩阵如右图 这里我们构建一个图的数据结构Graph，顺序遍历二维数组matrix的index[0]、index[1]、index[2]···获取出度。同理顺序遍历[0]index···获取入度。用java实现如下： p.
java图的深度优先遍历（dfs）和广度优先遍历(bfs)
qq_52025208的博客
05-08 779
import java.util.ArrayList; import java.util.Arrays; import java.util.LinkedList; import java.util.Queue; public class Graph { //顶点集合 private ArrayList<String> vertexList; //邻接矩阵 private int[][] edges; //边的数目 private int num..
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
《数据结构——C++实现》（第二版）课本源代码.zip
最新发布
06-16
《数据结构——C++实现》（第二版）是一本深入讲解这一主题的教材，提供了源代码供读者实践和学习。 本书的C++实现部分，旨在帮助读者掌握各种基本和高级数据结构，如数组、链表、栈、队列、树（二叉树、平衡树）、...
数据结构——二叉树的实现.zip
09-18
在这个压缩包里，你可能找到包括但不限于以下内容：二叉链表和左子右兄弟的C++或Java代码实现、相关算法的伪代码、详细的解释文本，甚至可能有示例图和练习题目。 总之，学习二叉树的实现，特别是二叉链表和左子右...
数据结构Java图图基础及图遍历PPT学习教案.pptx
10-08
图遍历是分析图的重要方法，包括深度优先搜索（DFS）和广度优先搜索（BFS）。在实际应用中，如公交网络系统、最短路径查询、物流和运输系统中，图遍历和图的其他特性（如生成树、最短路径）常常被用来解决实际问题。...
图的深度和广度优先遍历源程序及实验报告还有PPt
11-26
在这个场景中，我们关注的是图数据结构的一种遍历方法——深度优先搜索（DFS）和广度优先搜索（BFS）。这两种算法在解决实际问题如路径查找、网络爬虫、社交网络分析等方面有着广泛应用。 深度优先遍历是一种用于...
数据结构图的遍历源代码（深度和广度优先）
06-29
数据结构邻接矩阵广度优先搜索，无向图临界表广度优先搜索！
数据结构图的建立与深度和广度遍历代码
12-31
#include #include #include using namespace std; #define MAX_VERTEX_NUM 20//最大顶点数 #define MaxSize 400 typedef int QueueElementType;
图的深度、广度优先遍历（c语言）
12-20
本程序方便的实现了图的深度、广度优先遍历。是数据结构中的一部分，现与大家分享
图的遍历（深度优先和广度优先遍历算法）
04-18
图作为较为复杂的数据结构，对图的操作首先应该了解图的深度优先和广度优先搜索遍历算法！
数据结构—图—各种算法代码
gangangan0001的博客
10-27 1142
#include&lt;iostream&gt; using namespace std; const int maxSize = 99999; int v[maxSize]; int main() {     return 0; } /* 图的存储结构的定义 float MGraph[5][5]; for (int i = 0; i &lt; 5;++i)     for (int j ...
数据结构java 图实验代码_数据结构——图简介（java代码实现邻接矩阵）
weixin_34005394的博客
03-01 179
图：图是一种数据结构，其中节点可以具有一个或者多个相邻元素，俩个节点的连接称为边，节点也称为顶点。图的表示方式邻接矩阵邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1…n个点。邻接表邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失.邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链...
java实现图的深度优先遍历(dfs)和广度优先遍历(bfs)-------参考视频 韩顺平《java数据结构和算法》
qq_58814338的博客
06-17 437
java实现图的深度优先遍历(dfs)和广度优先遍历(bfs)-------参考视频 韩顺平《java数据结构和算法》
日撸java 三百行 （day 23 ）图的深度优先遍历
qq_44761856的博客
04-27 523
深度优先遍历可以借用一个辅助栈： 今天的测试用例（非强连通图）： 首先选取顶点D为初始顶点： 接着根据邻接矩阵的信息把E压栈： 由于D已经被访问过，并且E没有与其余节点相连接，将E出栈，D同理： 等D出栈后，队列为空，但是标记数组显示还有顶点未被访问，则程序接着运行： 代码及运行效果： /** ********************* * Depth first traversal. * * @param...
图
weixin_42393293的博客
10-20 109
图
图的广度优先遍历与深度优先遍历数据结构代码实现
05-25
广度优先遍历(BFS)： ```python from collections import deque def bfs(graph, start): visited = set() queue = deque([start]) while queue: vertex = queue.popleft() if vertex not in visited: ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值