DSA_图（java数据结构与算法）

最新推荐文章于 2024-05-10 20:31:04 发布
最新推荐文章于 2024-05-10 20:31:04 发布
阅读量195 收藏
点赞数 1
分类专栏： java数据结构与算法（韩顺平老师随堂笔记） 文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fine____/article/details/120602537
版权

图

图基本介绍

为什么要有图

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

图的举例说明

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

image-20210822223359672

图的常用概念

  1. 顶点(vertex)
  2. 边(edge)
  3. 路径
  4. 无向图(右图
  5. 有向图
  6. 带权图

image-20210822223531174

image-20210822223543361

图的表示方式

图的表示方式有两种：

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

邻接矩阵

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

image-20210822223655432

邻接表

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

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

  3. 举例说明

image-20210822223720961

图的快速入门案例

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

  2. 思路分析

    • 存储顶点 String 使用 ArrayList
    • 保存矩阵 int[][] edges

  3. 代码实现

public class Graph {

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

    /**
     * 构造器
     * @param n 构造有n个节点的图
     */
    public Graph (int n) {
        // 初始化矩阵和vertexList
        this.edges = new int[n][n];
        this.vertexList = new ArrayList<>(n);
        this.numOfEdges = 0;
    }

    /**
     * 插入节点
     * @param vertex 插入的节点的值
     */
    public void insertVertex(String vertex) {
        this.vertexList.add(vertex);
    }

    /**
     * 添加边
     * @param v1 表示顶点的下标，即第几个顶点 A->0 B->1 ...
     * @param v2 第二个顶点对应的下标
     * @param weight 表示路径的权，此处0表示未连接，1表示连接
     */
    public void insertEdge(int v1, int v2, int weight) {
        this.edges[v1][v2] = weight;
        this.edges[v2][v1] = weight;
        this.numOfEdges++;
    }

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

    /**
     * @param i 目标节点的下标
     * @return 返回节点i对应的数据 0->A 1->B
     */
    public String getValueByIndex(int i) {
        return this.vertexList.get(i);
    }

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

    /**
     * @return 返回节点的个数
     */
    public int getNumOfVertex() {
        return this.vertexList.size();
    }

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

}

图的深度优先遍历介绍

图遍历介绍

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

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

深度优先遍历基本思想

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

  1. 深度优先遍历，从初始访问结点出发，初始访问结点可能有多个邻接结点，深度优先遍历的策略就是首先访问第一个邻接结点，然后再以这个被访问的邻接结点作为初始结点，访问它的第一个邻接结点， 可以这样理解：每次都在访问完当前结点后首先访问当前结点的第一个邻接结点。
  2. 我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个结点的所有邻接结点进行横向访问。
  3. 显然，深度优先搜索是一个递归的过程

深度优先遍历算法步骤

  1. 访问初始结点 v，并标记结点 v 为已访问。
  2. 查找结点 v 的第一个邻接结点 w。
  3. 若 w 存在，则继续执行 4，如果 w 不存在（孤儿节点或遍历到结尾了），则回到第 1 步，将从 集合中下一个元素继续（重载for循环）。即A遍历完了就该其他节点了
  4. 若 w 未被访问，对 w 进行深度优先遍历递归（即把 w 当做另一个 v，然后进行步骤 123）。
  5. 查找结点 v 的 w 邻接结点的下一个邻接结点，转到步骤 3。
  6. 分析图

image-20210823093138045

/**
 * 得到第index节点第一个邻接节点的下标
 * @param index 欲的到其第一个邻接节点的节点下标
 * @return 返回index节点的第一个邻接节点下标，未找到则返回-1
 */
public int getFirstNeighbor(int index) {
    for (int i = 0; i < this.vertexList.size(); i++) {
        if (this.edges[i][index] > 0) {
            return i;
        }
    }
    return -1;
}

/**
 * 根据neighIndex获取index节点的下一个邻接节点
 * @param index 进行dfs的节点下标
 * @param neighborIndex index节点的一个邻接节点
 * @return 返回index的下一个邻接节点(在neighborIndex之后)
 */
public int getNextNeighbor(int index, int neighborIndex) {
    for (int i = neighborIndex + 1; i < this.vertexList.size(); i++) {
        if (this.edges[index][i] > 0) {
            return i;
        }
    }
    return -1;
}

/**
 * 深度优先遍历算法
 * @param isVisited 判断是否某节点被访问过
 * @param i 从下标为i的节点开始深度优先遍历
 */
public void dfs(boolean[] isVisited, int i) {
    // 访问该节点，输出
    System.out.print(getValueByIndex(i)+"==>");
    // 将该节点置为已访问
    isVisited[i] = true;
    // 查找该节点的第一个邻接节点
    int neighbor = this.getFirstNeighbor(i);
    while (neighbor != -1) {
        // 说明存在邻接节点
        if (!this.isVisited[neighbor]) {
            // 该邻接节点正好还未访问,递归调用dfs遍历
            this.dfs(isVisited, neighbor);
        }
        // 如果该节点已经被访问过，那就去找i节点的下一个邻接节点（第2个，第3个...）
        neighbor = this.getNextNeighbor(i, neighbor);
    }
}

/**
 * 对dfs进行重载，去遍历所有节点，进行dfs，以免有些孤儿节点访问不到
 */
public void dfs() {
    this.isVisited = new boolean[this.vertexList.size()];
    for (int i = 0; i < this.getNumOfVertex(); i++) {
        if (!this.isVisited[i]) {
            this.dfs(this.isVisited, i);
        }
    }

}

图的广度优先遍历

广度优先遍历基本思想

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

广度优先遍历算法步骤

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

  2. 结点 v 入队列

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

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

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

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

    • 若结点 w 尚未被访问，则访问结点 w 并标记为已访问。
    • 结点 w 入队列
    • 查找结点 u 的继 w 邻接结点后的下一个邻接结点 w，转到步骤 6。

image-20210823093936853

/**
 * 对i节点进行广度优先遍历
 * @param isVisited 判断是否某节点被访问过
 * @param i 欲进行bfs的节点下标
 */
private void bfs(boolean[] isVisited, int i) {
    // 队列的头结点的对应下标
    int head;
    // 邻接节点
    int neighbor;
    // 记录节点访问顺序的队列
    LinkedList queue = new LinkedList();
    // 访问节点，输出节点信息
    System.out.print(this.getValueByIndex(i)+"-->");
    // 标记已访问
    isVisited[i] = true;
    // 将节点加入队列
    queue.addLast(i);

    while (!queue.isEmpty()) {
        // 取出队列的头节点下标
        head = (Integer) queue.removeFirst();
        // 得到第一个邻接节点的下标
        neighbor = this.getFirstNeighbor(head);
        while (neighbor != -1) {
            // 找到了邻接节点
            if (!isVisited[neighbor]) {
                // 且正好没有被访问过，输出
                System.out.print(getValueByIndex(neighbor) + "-->");
                // 标记已访问
                isVisited[neighbor] = true;
                // 入队
                queue.addLast(neighbor);
            }
            // 如果没有找到邻接节点，以head为前驱节点，找neighbor后面的，head的另一个邻接节点
            neighbor = this.getNextNeighbor(head, neighbor);
        }
    }
}

/**
 * 重载bfs以遍历所有节点，以防有孤儿节点
 */
public void bfs() {
    this.isVisited = new boolean[this.vertexList.size()];
    for (int i = 0; i < this.getNumOfVertex(); i++) {
        if (!this.isVisited[i]) {
            this.bfs(this.isVisited, i);
        }
    }
}

图的深度优先 VS 广度优先

  1. 深度优先是通过递归，向纵向挖掘数据
  2. 广度优先是通过迭代，横向遍历数据
  3. 深度优先：从1进入，遍历到了2；再递归从2进入，遍历到4；再递归从4进入，遍历到8…
  4. 广度优先：从1进入，遍历到了2；返回来，遍历到3；等1的所有节点遍历完1了，再去1的子节点2，从2开始广度优先遍历…

image-20210823100313569

图的完整代码

package cn.chasing.DataStructure.graph;

import org.junit.Test;

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

/**
 * @author 柴柴快乐每一天
 * @create 2021-08-22  10:42 下午
 * <p>
 * 『Stay hungry, stay foolish. 』
 */


public class Graph {

    public static void main(String[] args) {
        int n = 9;
        String[] vertexes = {"1", "2", "3", "4", "5", "6", "7", "8", "9"};
        // 创建图对象
        Graph graph = new Graph(n);
        for (String vertex : vertexes) {
            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();

        graph.dfs();
        System.out.println();
        graph.bfs();

//        graph.dfs(graph.isVisited, 0);
    }

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

    /**
     * 构造器
     * @param n 构造有n个节点的图
     */
    public Graph (int n) {
        // 初始化矩阵和vertexList
        this.edges = new int[n][n];
        this.vertexList = new ArrayList<>(n);
        this.numOfEdges = 0;
    }

    public Graph() {
    }

    /**
     * 插入节点
     * @param vertex 插入的节点的值
     */
    public void insertVertex(String vertex) {
        this.vertexList.add(vertex);
    }

    /**
     * 添加边
     * @param v1 表示顶点的下标，即第几个顶点 A->0 B->1 ...
     * @param v2 第二个顶点对应的下标
     * @param weight 表示路径的权，此处0表示未连接，1表示连接
     */
    public void insertEdge(int v1, int v2, int weight) {
        this.edges[v1][v2] = weight;
        this.edges[v2][v1] = weight;
        this.numOfEdges++;
    }

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

    /**
     * @param i 目标节点的下标
     * @return 返回节点i对应的数据 0->A 1->B
     */
    public String getValueByIndex(int i) {
        return this.vertexList.get(i);
    }

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

    /**
     * @return 返回节点的个数
     */
    public int getNumOfVertex() {
        return this.vertexList.size();
    }

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

    /**
     * 得到第index节点第一个邻接节点的下标
     * @param index 欲的到其第一个邻接节点的节点下标
     * @return 返回index节点的第一个邻接节点下标，未找到则返回-1
     */
    public int getFirstNeighbor(int index) {
        for (int i = 0; i < this.vertexList.size(); i++) {
            if (this.edges[i][index] > 0) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 根据neighIndex获取index节点的下一个邻接节点
     * @param index 进行dfs的节点下标
     * @param neighborIndex index节点的一个邻接节点
     * @return 返回index的下一个邻接节点(在neighborIndex之后)
     */
    public int getNextNeighbor(int index, int neighborIndex) {
        for (int i = neighborIndex + 1; i < this.vertexList.size(); i++) {
            if (this.edges[index][i] > 0) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 深度优先遍历算法
     * @param isVisited 判断是否某节点被访问过
     * @param i 从下标为i的节点开始深度优先遍历
     */
    private void dfs(boolean[] isVisited, int i) {
        // 访问该节点，输出
        System.out.print(getValueByIndex(i)+"==>");
        // 将该节点置为已访问
        isVisited[i] = true;
        // 查找该节点的第一个邻接节点
        int neighbor = this.getFirstNeighbor(i);
        while (neighbor != -1) {
            // 说明存在邻接节点
            if (!this.isVisited[neighbor]) {
                // 该邻接节点正好还未访问,递归调用dfs遍历
                this.dfs(isVisited, neighbor);
            }
            // 如果该节点已经被访问过，那就去找i节点的下一个邻接节点（第2个，第3个...）
            neighbor = this.getNextNeighbor(i, neighbor);
        }
    }

    /**
     * 对dfs进行重载，去遍历所有节点，进行dfs，以免有些孤儿节点访问不到
     */
    public void dfs() {
        this.isVisited = new boolean[this.vertexList.size()];
        for (int i = 0; i < this.getNumOfVertex(); i++) {
            if (!this.isVisited[i]) {
                this.dfs(this.isVisited, i);
            }
        }
    }

    /**
     * 对i节点进行广度优先遍历
     * @param isVisited 判断是否某节点被访问过
     * @param i 欲进行bfs的节点下标
     */
    private void bfs(boolean[] isVisited, int i) {
        // 队列的头结点的对应下标
        int head;
        // 邻接节点
        int neighbor;
        // 记录节点访问顺序的队列
        LinkedList queue = new LinkedList();
        // 访问节点，输出节点信息
        System.out.print(this.getValueByIndex(i)+"-->");
        // 标记已访问
        isVisited[i] = true;
        // 将节点加入队列
        queue.addLast(i);

        while (!queue.isEmpty()) {
            // 取出队列的头节点下标
            head = (Integer) queue.removeFirst();
            // 得到第一个邻接节点的下标
            neighbor = this.getFirstNeighbor(head);
            while (neighbor != -1) {
                // 找到了邻接节点
                if (!isVisited[neighbor]) {
                    // 且正好没有被访问过，输出
                    System.out.print(getValueByIndex(neighbor) + "-->");
                    // 标记已访问
                    isVisited[neighbor] = true;
                    // 入队
                    queue.addLast(neighbor);
                }
                // 如果没有找到邻接节点，以head为前驱节点，找neighbor后面的，head的另一个邻接节点
                neighbor = this.getNextNeighbor(head, neighbor);
            }
        }
    }

    /**
     * 重载bfs以遍历所有节点，以防有孤儿节点
     */
    public void bfs() {
        this.isVisited = new boolean[this.vertexList.size()];
        for (int i = 0; i < this.getNumOfVertex(); i++) {
            if (!this.isVisited[i]) {
                this.bfs(this.isVisited, i);
            }
        }
    }


}
奥义喷火恐龙
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
dsa_java:使用Java的数据结构和算法
04-07
在编程领域，数据结构和算法...通过这个"dsa_java"项目，你可以深入学习和实践这些Java数据结构和算法，提升编程技能，并能够更好地理解和解决问题。项目的源代码可以作为学习和参考的实例，加深理论与实际操作的结合。
DSA_Java：Java Java中的数据结构和算法
02-05
注意： 最好的准备方法是克隆此存储库，并在进行过程中将问题标记为...未排序-摩尔投票算法，但使用快速排序后跟count [或] HashMap 5->发生超过n / 2次的元素-已排序 六个->最大差异，使得较小的数字出现在较大的数字
数据结构与算法(27):图的基本介绍(图的深度优先遍历,图的广度优先遍历)以及相关的案例代码
qq_42400763的博客
10-15 498
一. 图的基本介绍 为什么要有图? 回顾一下线性表和树 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要表示多对多的关系时， 这里我们就用到了图 图的举例说明 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。如图： 无向图 2. 有向图 3. 带权图 图的表示方式 图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。 邻接矩阵 邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于
【C语言】图的深度优先遍历&广度优先遍历(算法，代码一步到位)
Jaye513的博客
12-10 3758
图的两种遍历，你一定要学会
通俗易懂--Java数字签名算法（RSA，DSA,ECDSA）
最新发布
欢迎来到快乐懒洋洋的博客
05-10 249
签名算法
【数据结构】图的深度遍历与广度遍历
流星雨的博客
03-23 6956
图是一种常见的数据格式，它的遍历主要分为两种： 深度优先遍历(DFS):类似于二叉树的前序前序遍历 广度优先遍历(BFS):类似于二叉树的层次遍历 一、出度与入度 在讲图的遍历之前，我们需要先了解图的数据结构。 对于图，我们一般定义横向是出度，纵向是入度。比如对于左图我们转成领接矩阵如右图 这里我们构建一个图的数据结构Graph，顺序遍历二维数组matrix的index[0]、index[1]、index[2]···获取出度。同理顺序遍历[0]index···获取入度。用java实现如下： p.
大话数据结构-图的深度优先遍历和广度优先遍历
村长Korbin
03-02 9900
数据结构中图的深度优先遍历、广度优先遍历定义，邻接矩阵、邻接表、逆邻接表、十字链表、邻接多重表和边集数组的深度优先遍历实现和广度优先遍历实现。
图的两种遍历：深度优先遍历+广度优先遍历
qq_63806300的博客
08-16 1万+
图的遍历 广度 深度 c语言
Java DSA extensions:Java数据结构和算法扩展-开源
04-25
DSA扩展包含的类的目的与java.util中提供的类相似。 当前，它包含可排序的列表和映射，以及平衡的二进制搜索树和二进制数组搜索算法。
lb_dsa_cracker:450必须解决算法和数据结构方面的基本问题
03-31
《lb_dsa_cracker:450算法与数据结构基础挑战》 在计算机科学领域，算法和数据结构是核心的基础，对于任何编程语言，包括Java，掌握它们的重要性不言而喻。"lb_dsa_cracker"这个项目似乎是一个旨在帮助开发者提升...
股票买卖最佳时机leetcode-Dsa_Interview_Preparation:数据结构和算法面试准备
07-07
Java Python 解释。 2： Beggars_outside_temple C++ Java Python 解释。 3： Bob_and_queries C++ Java Python 解释。 4： Count_of_range_sum C++ Java Python 解释。 5： Count_of_smaller_numbers_after_self ...
图的遍历——深度优先搜索（DFS）与广度优先搜索（BFS）（附带C语言源码）
weixin_73602725的博客
05-10 2992
在此之前我们学习过了图的一些基本概念，如同在二叉树中我们有前序遍历，中序遍历，后序遍历一般，在图中也有两种特殊的遍历方式——深度优先遍历与广度优先遍历。
图的遍历——深度优先遍历与广度优先遍历
m0_72579201的博客
02-08 5438
图的遍历需要定义一个辅助数组以记录某个顶点是否曾被访问，其遍历方式分为深度优先搜索与广度优先搜索。深度优先搜索符合递归的特性，广度优先搜索需要一个队列结构以实现图的层序遍历。这两种遍历方式的时间与空间复杂度在所选用图的存储结构相同的情况下相同，也就是所搜索算法的复杂度与搜索方式本身无关，与图的存储结构有关。一般而言，稠密图选用邻接矩阵存储，稀疏图选取邻接表存储。
数据结构学习笔记——图的遍历算法（深度优先搜索和广度优先搜索）
热门推荐
小宇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单链表，搜索下一个未被访问的邻接顶点；....
数据结构——详解图的深度优先遍历和广度优先遍历及代码实现
诶你爱我吗的博客
12-30 1万+
图的深度优先遍历和广度优先遍历： 从本质上来说都是用来访问图中的所有结点的，只是两种访问的方式不同，深度优先遍历用的是堆栈，先进的后出，而广度优先遍历用的是队列的思想。 1.图的深度优先遍历 1.1基本思想： ⑴ 访问顶点v； ⑵ 从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历； ⑶ 重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。 例如我们需要用深度优先遍历下面这个图...
【数据结构】图以及图的遍历（深度遍历和广度遍历）
qq_25218219的博客
11-12 4439
图 在数学中，图是描述于一组对象的结构，其中某些对象对在某种意义上是“相关的”。这些对象对应于称为顶点的数学抽象（也称为节点或点），并且每个相关的顶点对都称为边（也称为链接或线）。通常，图形以图解形式描绘为顶点的一组点或环，并通过边的线或曲线连接。 图形是离散数学的研究对象之一。 ------百度百科 6.1 基本术语 图：记为 G＝( V, E ) 其中：V 是G
图详解第二篇：图的遍历（广度优先+深度优先）
m0_70980326的博客
10-09 4269
图的遍历详解：DFS+BFS
图的广度优先遍历
实践求真知
06-25 8085
广度优先遍历又称为宽度优先搜索，是最常见的图的搜索方法之一。广度优先搜索指从某一点出发，一次性访问所有未被访问的邻节点，再依次从这些已访问过的邻接点出发，一层一层地访问。广度优先遍历是按照广度优先搜索的方式对图进行遍历的。按照广度优先搜索的顺序，上图的访问顺序是：1 2 3 4 5 6广度优先遍历的秘籍：先被访问的节点，其邻节点先被访问。根据广度优先遍历的秘籍，先来先服务，可以借助队列实现。因为对每个节点只访问一次，所以可以设置一个辅助数组 visited[i] = false，表示第 i 个节点未被访问；
数据结构与算法12：图、广度优先、深度优先
浮尘笔记
06-08 1470
树表达的是层级化的结构，图表达的是网络化的结构。图的应用：社交网络和地图交通网络。图的存储方式1：邻接矩阵，依赖一个二维数组，空间换时间；图的存储方式2：邻接链表，底层依赖一个链表，时间换空间。图的算法分为广度优先搜索（BFS）和深度优先搜索（DFS），主要实现在图中从一个顶点出发到另一个顶点的路径。广度优先搜索需要使用队列来实现，深度优先搜索用的是回溯思想，可以使用栈来实现的。深度优先和广度优先的时间复杂度都是 O(边的个数)，空间复杂度是 O(顶点的个数)。
dsa 数据结构与算法
01-14
DSA是指数据结构与算法。数据结构是指数据的组织和存储方式，而算法是指解决问题的方法和步骤。数据结构与算法是计算机科学中非常重要的一个领域，它们是构建高效程序和解决复杂问题的基础。 数据结构包括数组、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值