程序员经验分享-hwhale

【数据结构】图-图的遍历_广度优先遍历（动态图解、c++、java）

2023-10-27

GitHub同步更新（已分类）：Data_Structure_And_Algorithm-Review

公众号：URLeisure 的复习仓库
公众号二维码见文末

以下是本篇文章正文内容，下面案例可供参考。

一、概述

  • 图的遍历和树的遍历类似，是从图的某一顶点出发，按照某种搜索方式对图中所有的顶点访问一次且仅一次。
  • 图的遍历可以解决很多搜索问题，在实际中应用非常广泛。
  • 图的遍历根据搜索方式的不同，分为：广度优先搜索和深度优先搜索。

二、广度优先搜索

  • 广度优先搜索（Breadth First Search，BFS），又称宽度优先搜索，是最常见的图搜索方法之一。
  • 广度优先搜索是从某个顶点（源点）出发，一次性访问所有未被访问的邻接点，再依次从这些访问过的邻接点出发。
  • 广度优先遍历是按照广度优先搜索的方式对图进行遍历。

图解

在这里插入图片描述

在上图中，设 A 为源点。

  1. 从 A 出发，访问 A 的邻接点 B、C；
  2. 再从 B 出发，访问 B 的邻接点 D、E；
  3. 从 C 出发，C 的邻接点 B、E 已被访问；
  4. 从 D 出发，D 没有邻接点；
  5. 从 E 出发，E 的邻接点 D 已被访问；
  6. 访问完毕。

访问路径如图。
在这里插入图片描述
规律：先被访问的顶点，其邻接点先被访问。

根据这个规律，我们可以用队列来实现广度优先遍历。

创建 vis[ ]，来标记已被访问的顶点。

BFS树

广度优先遍历经过的顶点及边，称为广度优先生成树，简称 BFS树。

如图为图例的广度优先生成树。
在这里插入图片描述

如果是非连通图，则每一个连通分量会产生一棵 BFS树，合在一起称为 BFS森林。

代码

算法步骤：

  1. 初始化图的所有顶点未被访问，初始化一个空队列；
  2. 从图的某个顶点 V 出发，访问 V 并标记已访问，将 V 入队；
  3. 如果队列非空，则继续执行，否则算法结束；
  4. 队头元素 V 出队，依次访问 V 的所有未被访问的邻接点，标记已访问并入队，转向步骤3。

在这里插入图片描述

上图中示例：

  1. A 入队；
  2. A 出队，判断 A 的邻接点；
  3. A 的邻接点 B、C 入队；
  4. B 出队，判断 B 的邻接点；
  5. B 的邻接点 D、E 入队；
  6. C 出队，判断 C 的邻接点，都被标记不如队列；
  7. D 出队，判断 D 的邻接点；
  8. E 出队，判断 E 的邻接点。
  9. 队列为空，终止。

在这里插入图片描述
（这是邻接矩阵的结果，如果是邻接表的话，结果是ACBED。因为邻接表的添加节点类似于头插法，后输入的在前面。）

初始化见完整代码。

邻接矩阵实现

c++代码如下（示例）：

void BFS_AM(AMGraph G, VexType v) {
    queue<VexType> Q;
    int i = LocateVex(G, v);
    vis[i] = true;
    Q.push(v);
    while (!Q.empty()) {
        VexType u = Q.front();
        cout << u << "\t";//可以把 u 存起来最后输出，也可以直接在这里输出
        i = LocateVex(G, u);
        Q.pop();
        for (int j = 0; j < G.vexnum; j++) {
            if (G.Edge[i][j] && !vis[j]) {
                vis[j] = true;
                Q.push(G.Vex[j]);
            }
        }
    }
}

java代码如下（示例）：

private static void BFS_AM(AMGraph g, String v) {
	LinkedList<String> queue = new LinkedList<>();
    int i = locateVex(g, v);
    vis[i] = true;
    queue.add(v);
    while (!queue.isEmpty()) {
        String u = queue.pop();
        System.out.print(u + "\t");//可以把 u 存起来最后输出，也可以直接在这里输出
        i = locateVex(g, u);
        for (int j = 0; j < g.vexnum; j++) {
            if (g.edge[i][j] != 0 && !vis[j]) {
                vis[j] = true;
                queue.add(g.vex[j]);
            }
        }
    }
}

邻接表实现

c++代码如下（示例）：

void BFS_AL(ALGraph G, VexType v) {
    queue<VexType> Q;
    int i = LocateVex(G, v);
    vis[i] = true;
    Q.push(v);
    while (!Q.empty()) {
        VexType u = Q.front();
        cout << u << "\t";//可以把 u 存起来最后输出，也可以直接在这里输出
        Q.pop();
        i = LocateVex(G, u);
        AdjNode *p = G.Vex[i].first;
        while (p) {
            if (!vis[p->v]) {
                Q.push(G.Vex[p->v].data);
                vis[p->v] = true;
            }
            p = p->next;
        }
    }
}

java代码如下（示例）：

private static void BFS_AL(ALGraph g, String v) {
    LinkedList<String> queue = new LinkedList<>();
    int i = locateVex(g, v);
    vis[i] = true;
    queue.add(v);
 	while (!queue.isEmpty()) {
       	String u = queue.pop();
        System.out.print(u + "\t");//可以把 u 存起来最后输出，也可以直接在这里输出
        i = locateVex(g, u);
        AdjNode p = g.vex[i].first;
       	while (p != null) {
            if (!vis[p.v]) {
                vis[p.v] = true;
                queue.add(g.vex[p.v].data);
            }
            p = p.next;
        }
    }
}

链式前向星实现

  • 之前没写链式前向星的，因为我感觉过程会了写起来没有难度，但是。。。

c++代码如下（示例）：

void BFS(int x) {
    queue<int> q;
    flag[x] = true;
    q.push(x);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        cout << u << "\t";//可以把 u 存起来最后输出，也可以直接在这里输出
        for (int i = head[u]; ~i; i = e[i].next) {
            int v = e[i].to;
            if (!flag[v]) {
                flag[v] = true;
                q.push(v);
            }
        }
    }
}

java代码如下（示例）：

public static void bfs(int x) {
    LinkedList<Integer> queue = new LinkedList<>();
    flag[x] = true;
    queue.add(x);
    while (!queue.isEmpty()) {
        int u = queue.pop();
        System.out.print(u + "\t");
        for (int i = head[u]; i != -1; i = e[i].next) {
            int v = e[i].to;
            if (!flag[v]) {
                flag[v] = true;
                queue.add(v);
           	}
        }
    }
}

三、完整代码

邻接矩阵版

c++代码如下（示例）：

#include "iostream"
#include "cstring"
#include "queue"

using namespace std;

typedef char VexType;
typedef int EdgeType;
#define MAXN 100//注意，开太大的话二维数组受不了

struct AMGraph {
    VexType Vex[MAXN];
    EdgeType Edge[MAXN][MAXN];
    int vexnum, edgenum;
};

bool vis[MAXN];

void Init() {
    memset(vis, false, sizeof vis);
}

int LocateVex(AMGraph G, VexType x) {
    for (int i = 0; i < G.vexnum; i++) {
        if (G.Vex[i] == x) {
            return i;
        }
    }
    return -1;
}

void CreateAMGraph(AMGraph &G) {
    cin >> G.vexnum >> G.edgenum;
    for (int i = 0; i < G.vexnum; i++) {
        cin >> G.Vex[i];
    }
    for (int i = 0; i < G.vexnum; i++) {
        for (int j = 0; j < G.vexnum; j++) {
            G.Edge[i][j] = 0;
        }
    }
    VexType u, v;
    while (G.edgenum--) {
        cin >> u >> v;
        int i = LocateVex(G, u);
        int j = LocateVex(G, v);
        if (i != -1 && j != -1) {
            G.Edge[i][j] = 1;
        } else {
            cout << "输入了不存在的节点，请重新输入" << endl;
            G.edgenum++;
        }
    }
}

void BFS_AM(AMGraph G, VexType v) {
    queue<VexType> Q;
    int i = LocateVex(G, v);
    vis[i] = true;
    Q.push(v);
    while (!Q.empty()) {
        VexType u = Q.front();
        cout << u << "\t";
        i = LocateVex(G, u);
        Q.pop();
        for (int j = 0; j < G.vexnum; j++) {
            if (G.Edge[i][j] && !vis[j]) {
                vis[j] = true;
                Q.push(G.Vex[j]);
            }
        }
    }
}

int main() {
    Init();
    AMGraph G;
    CreateAMGraph(G);
    VexType v;
    cin >> v;
    BFS_AM(G, v);
    return 0;
}
/*
5 7
A B C D E
A B
A C
B D
B E
C B
C E
E D
A
 */

java代码如下（示例）：

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;

public class A {
    private static Scanner sc = new Scanner(System.in);
    private static final int MAX = 100;

    private static class AMGraph {
        String vex[] = new String[MAX];
        int edge[][] = new int[MAX][MAX];
        int edgenum, vexnum;
    }

    private static boolean vis[] = new boolean[MAX];

    private static void init() {
        Arrays.fill(vis, false);
    }

    private static int locateVex(AMGraph g, String x) {
        for (int i = 0; i < g.vexnum; i++) {
            if (g.vex[i].equals(x)) {
                return i;
            }
        }
        return -1;
    }

    private static void createAMGraph(AMGraph g) {
        g.vexnum = sc.nextInt();
        g.edgenum = sc.nextInt();
        for (int i = 0; i < g.vexnum; i++) {
            g.vex[i] = sc.next();
        }
        for (int i = 0; i < g.vexnum; i++) {
            for (int j = 0; j < g.vexnum; j++) {
                g.edge[i][j] = 0;
            }
        }
        String u, v;
        while (g.edgenum-- > 0) {
            u = sc.next();
            v = sc.next();
            int i = locateVex(g, u);
            int j = locateVex(g, v);
            if (i != -1 && j != -1) {
                g.edge[i][j] = 1;
            } else {
                System.out.println("输入了不存在的节点，请重新输入");
                g.edgenum++;
            }
        }
    }

    private static void BFS_AM(AMGraph g, String v) {
        LinkedList<String> queue = new LinkedList<>();
        int i = locateVex(g, v);
        vis[i] = true;
        queue.add(v);
        while (!queue.isEmpty()) {
            String u = queue.pop();
            System.out.print(u + "\t");
            i = locateVex(g, u);
            for (int j = 0; j < g.vexnum; j++) {
                if (g.edge[i][j] != 0 && !vis[j]) {
                    vis[j] = true;
                    queue.add(g.vex[j]);
                }
            }
        }
    }

    public static void main(String[] args) {
        AMGraph g = new AMGraph();
        init();
        createAMGraph(g);
        String v = sc.next();
        BFS_AM(g, v);
    }
}
/*
5 7
A B C D E
A B
A C
B D
B E
C B
C E
E D
A
 */

邻接表版

c++代码如下（示例）：

#include "iostream"
#include "cstring"
#include "queue"

using namespace std;
typedef char VexType;
#define MAX 100

struct AdjNode {
    int v;
    AdjNode *next;
};

struct VexNode {
    VexType data;
    AdjNode *first;
};

struct ALGraph {
    VexNode Vex[MAX];
    int vexnum, edgenum;
};
bool vis[MAX];

void Init() {
    memset(vis, false, sizeof vis);
}

void InsertEdge(ALGraph &G, int i, int j) {
    AdjNode *s;
    s = new AdjNode;
    s->v = j;
    s->next = G.Vex[i].first;
    G.Vex[i].first = s;
}

int LocateVex(ALGraph G, VexType x) {
    for (int i = 0; i < G.vexnum; i++) {
        if (G.Vex[i].data == x) {
            return i;
        }
    }
    return -1;
}

void CreateALGraph(ALGraph &G) {
    cin >> G.vexnum >> G.edgenum;
    for (int i = 0; i < G.vexnum; i++) {
        cin >> G.Vex[i].data;
        G.Vex[i].first = nullptr;
    }
    VexType u, v;
    while (G.edgenum--) {
        cin >> u >> v;
        int i = LocateVex(G, u);
        int j = LocateVex(G, v);
        if (i != -1 && j != -1) {
            InsertEdge(G, i, j);
        } else {
            cout << "输入了不存在的节点，请重新输入" << endl;
            G.edgenum++;
        }
    }
}

void BFS_AL(ALGraph G, VexType v) {
    queue<VexType> Q;
    int i = LocateVex(G, v);
    vis[i] = true;
    Q.push(v);
    while (!Q.empty()) {
        VexType u = Q.front();
        cout << u << "\t";
        Q.pop();
        i = LocateVex(G, u);
        AdjNode *p = G.Vex[i].first;
        while (p) {
            if (!vis[p->v]) {
                Q.push(G.Vex[p->v].data);
                vis[p->v] = true;
            }
            p = p->next;
        }
    }
}

int main() {
    ALGraph G;
    Init();
    CreateALGraph(G);
    VexType v;
    cin >> v;
    BFS_AL(G, v);
    return 0;
}
/*
5 7
A B C D E
A B
A C
B D
B E
C B
C E
E D
A
 */

java代码如下（示例）：

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;

public class A {
    private static Scanner sc = new Scanner(System.in);
    private static final int MAX = 100;

    private static class AdjNode {
        int v;
        AdjNode next;
    }

    private static class VexNode {
        String data;
        AdjNode first;
    }

    private static class ALGraph {
        VexNode vex[] = new VexNode[MAX];
        int vexnum, edgenum;
    }

    private static boolean vis[] = new boolean[MAX];

    private static void init() {
        Arrays.fill(vis, false);
    }

    private static void insertEdge(ALGraph g, int i, int j) {
        AdjNode p = new AdjNode();
        p.v = j;
        p.next = g.vex[i].first;
        g.vex[i].first = p;
    }

    private static int locateVex(ALGraph g, String x) {
        for (int i = 0; i < g.vexnum; i++) {
            if (g.vex[i].data.equals(x)) {
                return i;
            }
        }
        return -1;
    }

    private static void createALGraph(ALGraph g) {
        g.vexnum = sc.nextInt();
        g.edgenum = sc.nextInt();
        for (int i = 0; i < g.vexnum; i++) {
            g.vex[i] = new VexNode();
            g.vex[i].data = sc.next();
            g.vex[i].first = null;
        }
        String u, v;
        while (g.edgenum-- > 0) {
            u = sc.next();
            v = sc.next();
            int i = locateVex(g, u);
            int j = locateVex(g, v);
            if (i != -1 && j != -1) {
                insertEdge(g, i, j);
            } else {
                System.out.println("输入了不存在的节点，请重新输入");
                g.edgenum++;
            }
        }
    }

    private static void BFS_AL(ALGraph g, String v) {
        LinkedList<String> queue = new LinkedList<>();
        int i = locateVex(g, v);
        vis[i] = true;
        queue.add(v);
        while (!queue.isEmpty()) {
            String u = queue.pop();
            System.out.print(u + "\t");
            i = locateVex(g, u);
            AdjNode p = g.vex[i].first;
            while (p != null) {
                if (!vis[p.v]) {
                    vis[p.v] = true;
                    queue.add(g.vex[p.v].data);
                }
                p = p.next;
            }
        }
    }

    public static void main(String[] args) {
        ALGraph g = new ALGraph();
        init();
        createALGraph(g);
        String v = sc.next();
        BFS_AL(g, v);
    }
}
/*
5 7
A B C D E
A B
A C
B D
B E
C B
C E
E D
A
 */

链式前向星版

c++代码如下（示例）：

#include<iostream>
#include<cstring>
#include<queue>

using namespace std;

const int N = 1e3;
struct Edge {
    int to;
    int next;
} e[N];
int head[N], cnt;
bool flag[N];

void Init() {
    memset(head, -1, sizeof head);
    memset(flag, false, sizeof flag);
    cnt = 0;
}

void add(int u, int v) {
    e[cnt].to = v;
    e[cnt].next = head[u];
    head[u] = cnt++;
}

void BFS(int x) {
    queue<int> q;
    flag[x] = true;
    q.push(x);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        cout << u << "\t";//可以把 u 存起来最后输出，也可以直接在这里输出
        for (int i = head[u]; ~i; i = e[i].next) {
            int v = e[i].to;
            if (!flag[v]) {
                flag[v] = true;
                q.push(v);
            }
        }
    }
}

int main() {
    Init();
    int n;
    cin >> n;
    int u, v;
    for (int i = 0; i < n; i++) {
        cin >> u >> v;
        add(u, v);
    }

    cin >> v;
    BFS(v);
    cout << endl;
    return 0;
}
/*
7
1 2
1 3
2 4
2 5
3 2
3 5
5 4
1
 */

java代码如下（示例）：

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Scanner;

public class A {
    public static Scanner sc = new Scanner(System.in);
    public static final int N = 1000;

    public static class Edge {
        int to;
        int next;
    }

    public static Edge e[] = new Edge[N];
    public static int head[] = new int[N];
    public static boolean flag[] = new boolean[N];
    public static int cnt;

    public static void init() {
        Arrays.fill(head, -1);
        Arrays.fill(flag, false);
        cnt = 0;
    }

    public static void add(int u, int v) {
        e[cnt] = new Edge();
        e[cnt].to = v;
        e[cnt].next = head[u];
        head[u] = cnt++;
    }

    public static void bfs(int x) {
        LinkedList<Integer> queue = new LinkedList<>();
        flag[x] = true;
        queue.add(x);
        while (!queue.isEmpty()) {
            int u = queue.pop();
            System.out.print(u + "\t");
            for (int i = head[u]; i != -1; i = e[i].next) {
                int v = e[i].to;
                if (!flag[v]) {
                    flag[v] = true;
                    queue.add(v);
                }
            }
        }
    }

    public static void main(String[] args) {
        init();
        int n = sc.nextInt();
        int v, u;
        for (int i = 0; i < n; i++) {
            u = sc.nextInt();
            v = sc.nextInt();
            add(u, v);
        }

        v = sc.nextInt();
        bfs(v);
    }
}
/*
7
1 2
1 3
2 4
2 5
3 2
3 5
5 4
1
 */

四、总结

算法复杂度分析

广度优先搜索的过程实质上是对每个顶点搜索其邻接点的过程，图的存储方式不同，其算法复杂度也不同。

基于邻接矩阵的 BFS 算法

时间复杂度：

  • 查找每个顶点的邻接点需要 O ( n ) O(n) O(n) 时间，一共 n 个顶点，总时间复杂度为 O ( n 2 ) O(n^2) O(n2) 。

空间复杂度：

  • 使用了一个辅助队列，最坏的情况下每个顶点入队一次，空间复杂度为 O ( n ) O(n) O(n) 。

基于邻接表的 BFS 算法

时间复杂度：

  • 查找顶点 Vi 的邻接点需要 O ( d ( V i ) ) O(d(V_i)) O(d(Vi​)) 时间， d ( V i ) d(V_i) d(Vi​) 为 Vi 的出度（无向图为度）。
  • 对有向图，所有顶点的出度之和等于边数 e；对无向图，所有顶点的度之和为 2e。
  • 因此查找邻接点的时间复杂度为 O ( n ) O(n) O(n)，加上初始化时间 O ( n ) O(n) O(n)，总的时间复杂度为 O ( n + e ) O(n+e) O(n+e)。

空间复杂度：

  • 使用了一个辅助队列，最坏的情况下每个顶点入队一次，空间复杂度为 O ( n ) O(n) O(n)。

注意

图的邻接矩阵是唯一的，因此基于邻接矩阵的 BFS 或 DFS 遍历序列也是唯一的。

图的邻接表不是唯一的，边的输入顺序不同，正序或逆序建表都会影响邻接表的邻接点顺序，因此基于邻接表的 BFS 或 DFS 遍历序列不是唯一的。

关注公众号，感受不同的阅读体验

请添加图片描述

下期预告：图的遍历_深度优先遍历

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

URLeisure的数据结构之旅

数据结构

Java

c

广度优先

【数据结构】图-图的遍历_广度优先遍历（动态图解、c++、java） 的相关文章

  • 使用 java 中的准备好的语句插入自定义 SQL 类型

    我有一些自定义类型 它们基本上都是枚举 以下是它们的外观示例 CREATE TYPE card suit AS ENUM spades clubs hearts diamonds 我在 Java 中有一些准备好的语句 看起来像这样 Setu

  • 二元运算符重载、隐式类型转换

    class my bool private bool value public my bool bool value value value explicit operator bool return value friend my boo

  • C++ 为非虚方法指定初始化

    我有 a h 如下所示 class A public void doSomething 0 然后我有 b h 如下所示 include a h class b public A public void doSomething 我只是想通过尝

  • 模板“内联”函数的静态局部变量[重复]

    这个问题在这里已经有答案了 static的局部变量inline如果我的理解是正确的 C 中的函数保证像单个全局变量一样存在 如果inline函数是一个模板 编译器可以在哪里生成该函数的多个版本 下面这篇文章应该很好地回答你的问题 http

  • 如何在 Struts 2 中访问 OGNL 跟踪评估？

    有人告诉我要优化网络应用程序 为此 我使用JProfiler https www ej technologies com products jprofiler overview html 我注意到很大一部分响应时间都花在了表示层上 特别是当

  • 访问结构向量

    我有一个结构 struct OutputStore int myINT string mySTRING 如果我创建一个 OutputStore 类型的数组 如下所示 OutputStore OutputFileData new Output

  • 使用 JPA 存储库保留 Spring Batch ItemWriter 的问题

    我对春季批次有疑问ItemWriter它依赖于 JPA 存储库来更新数据 这里是 Component public class MessagesDigestMailerItemWriter implements ItemWriter

  • C++20 views::join 在生成的嵌套范围::single_view 上进入无限循环

    我正在使用 GCC 实现 v10 2 和 v11 来处理 C 20 范围 测试的行为std views join https en cppreference com w cpp ranges join view 我尝试使用生成嵌套视图sin

  • 未找到 GroovyEvaluator

    我会尝试在以下位置制作我的 PIE 3D 报告iReport 在我的 struts xml 中 我用这个来调用我的报告

  • 从 TFS 下载工作项附件（文件已损坏）

    我正在尝试创建 C 代码 因此我可以自动从 Team Foundation Server 下载 BUGS 预定义查询的所有附件 该代码似乎工作得很好 但所有下载的文件都因意外原因而损坏 我无法查看它们 有人可以看一下代码并分享意见吗 非常感

  • 如何组织课程、课程包[关闭]

    Closed 这个问题是无关 help closed questions 目前不接受答案 您如何决定包名称应该是什么以及什么类应该放入哪个包中 我正在开发一个项目 在该项目中 我不断添加 删除类 并且不确定我是否需要一个新包 或者应该将其添

  • 使用可变参数模板函数计算多个值的平均值

    我正在尝试编写一个函数来确定任意数量参数的平均值 所有参数都具有相同的类型 出于学习目的 我尝试使用可变参数模板函数来做到这一点 这是我到目前为止所拥有的 template

  • 我们可以使用 C# 录制发送到扬声器的声音吗

    我有一个软件 SoundTap Streaming Audio Recorder 它记录发送到扬声器的任何音频 无论流是来自网络还是来自某些文件或麦克风 我可以在桌面应用程序中制作这样的应用程序 以便我可以录制发送到扬声器的流 无论来源如何

  • 如何将这个基于代码的 WPF 工具提示转换为 Silverlight？

    以下工具提示代码适用于WPF 我正在努力让它发挥作用银光 但它给了我这些errors TextBlock does not contain a definition for ToolTip Cursors does not contain

  • 启动 Firefox 并等待其关闭

    Question 我想启动 Firefox 网络浏览器作为访问特定网站的过程 然后等到它关闭 一种特殊情况是浏览器可能已经打开并正在运行 因为用户可能已经访问过某个网站 在这种情况下 浏览器可能会在现有窗口中打开一个新选项卡 并且新启动的进

  • 无法验证 serde：org.openx.data.jsonserde.jsonserde

    我编写了这个查询来在配置单元上创建一个表 我的数据最初是 json 格式 所以我已经下载并构建了 serde 并添加了它运行所需的所有 jar 但我收到以下错误 FAILED Execution Error return code 1 fr

  • int 类型的构造函数

    考虑到成本 这些情况是否相同 case 1 int a 5 case 2 int a 5 case 3 int a a 5 这三种语法是不同的 请耐心等待 我使用用户定义类型而不是 int 稍后我将回到 int T a 5 Direct i

  • 定义一个断言，即使定义了 NDEBUG，该断言也有效

    我想定义一个assert与标准相同的宏assert 3 http man7 org linux man pages man3 assert 3 html调用 但它不会被预处理器删除NDEBUG被定义为 这样的呼唤 让我们称之为assert2

  • 在 Visual Studio C++ 资源编辑器中导入 png 文件

    我希望能够在 Visual Studio 资源编辑器中导入 png 文件 以便能够在不同的其他项目中使用嵌入的资源 有解决办法吗 我知道它适用于位图 但我对 png 感兴趣 因为即使在较低格式 16x16 或 32x32 上也可以使用 透明

  • 使用 Powershell 或 C# 获取 Azure“文件和文件夹”作业状态

    我一直在尝试找到一种方法来获取在 AzureRM 中运行的几个客户上运行的 文件和文件夹 备份作业的状态 可以在 AzureRm 门户中手动找到状态 恢复服务保管库 gt 作业 gt 备份作业 使用powershell不显示任何作业信息 G

随机推荐

  • python批量发送带附件的邮件时，收到的附件名异常且后缀为bin，解决办法

    1 问题描述 在使用 Python 内置的模块 smtplib 发送带中文名的附件邮件时 数据可以正常传输 但是但收件人收到的附件格式是bin 附件名也不是发送时的名称 附注 smtp Simple Mail Transfer Protoc

  • 进一步理解angular

    在上一篇文章中我介绍了安装和结构 以及运行过程 https blog csdn net weixin 42603009 article details 94382945 我们进一步理解其中的数据单向 双向 组建传值 Modules等的理解

  • C语言编译过程、VIM常用命令

    一 编译过程 1 预处理 gcc E 源文件 c o 源文件 i 预处理宏以及注释 2 编译 gcc S 源文件 i o 源文件 s 通过编译转换为汇编文件 3 汇编 gcc c 源文件 s o 源文件 o 经汇编转换为二进制文件 4 链接

  • linux创建链接文件

    链接文件的创建 1 概念 链接文件就类似我们windows的快捷方式 只保留目标文件的地址 不占用存储空间 使用链接文件与使用目标文件的效果是一样的 2 为什么要使用链接文件 在windows都会把文件放在一个比较大的磁盘中 我们每次需要使

  • ChatGPT 速通手册——GPT 训练数据集介绍

    GPT 训练数据集介绍 所有人工智能算法都会分为训练和推理两步 算法的效果好坏 很大程度上取决于训练数据本身的质量 ChatGPT 所用的训练数据 openai 公司没有单独公布过细节 不过考虑到 ChatGPT 是在前序 GPT 算法基础

  • linux使用记录（一）

    1 tar 解压tar xvf file tar 解压 tar包 tar xzvf file tar gz 解压tar gz tar xjvf file tar bz2 解压 tar bz2 tar xZvf file tar Z 解压ta

  • 使用ADO.NET访问数据库

    一 ADO NET 数据库访问的方法和技术 二 ADO NEt的重要组件 1 DataSet 独立于数据源的数据访问 2 Net framework数据提供程序 用于连接到数据库执行命令和检索结果 三 NET数据提供程序的四个核心对象 1

  • 无向图——邻接表和邻接矩阵的实现

    邻接矩阵 include

  • 封装七牛云存储工具类

    文章目录 封装七牛云存储工具类 为啥选择七牛云 当然是因为它能免费使用喽 白嫖怪哈哈哈 图片存储方案 Java SDK操作七牛云 封装工具类 封装七牛云存储工具类 为啥选择七牛云 当然是因为它能免费使用喽 白嫖怪哈哈哈 图片存储方案 在实际

  • UnityShader——Compute Shader

    Compute Shader是基于DX11 SM4 5 的在GPU上运行的程序 通过Compute Shader我们可以将大量可以并行的计算放到GPU中计算从而节省CPU资源 Unity 5 6版本提供的 Graphics DrawMesh

  • U盘数据丢失是什么原因？轻松让U盘数据恢复的教程

    在数字化时代 我们不可避免地使用各种便携式存储设备 如U盘 来传输和存储重要数据 然而 有时我们可能不小心删除了U盘中的文件 或者格式化了U盘等等而导致数据丢失 这种情况下 你可能会困惑地想知道 是否有简单的方式可以快速而轻松地恢复U盘中丢

  • 解决报错：You don‘t have enough free space in /var/cache/apt/archives/.

    apt安装package时遇到问题 You don t have enough free space in var cache apt archives 问题 var 目录下空间不足 apt下载时没有地方存放缓存文件 解决方法 删除部分日志

  • Java中解决CAS机制出现的ABA问题

    Java中解决CAS机制出现的ABA问题 学习目标 Java中解决CAS机制出现的ABA问题 1 先了解一下什么是CAS 2 CAS的底层原理 3 CAS的问题 4 怎么解决ABA问题 1 先了解一下什么是CAS 一句话总结就是 比较并交换

  • 分库分表需要考虑的问题及方案

    转自 http www jianshu com p 32b3e91aa22c from timeline 分库分表需要考虑的问题及方案 作者 jackcooper 2017 02 08 16 08 字数 5042 阅读 5240 评论 3

  • 【手写一个RPC框架】simpleRPC-06

    目录 前言 实现 zookeeper安装与使用 项目创建 依赖配置 register client service server common codec 文件结构 运行 本项目所有代码可见 https github com weiyu z

  • Lock锁和Condition条件

    Lock的特性 Lock不是Java语言内置的 synchronized是在JVM层面上实现的 如果代码执行出现异常 JVM会自动释放锁 但是Lock不行 要保证锁一定会被释放 就必须将unLock放到finally 中 手动释放 在资源竞

  • OSPF协议

    提示 文章写完后 目录可以自动生成 如何生成可参考右边的帮助文档 HCIA第四天 前言 一 OSPF协议 二 LAS优化 特殊区域 1 解决OSPF的不规则区域 三 扩展配置 前言 一 OSPF协议 OSPF 开放式最短路径优先协议 无类别

  • spring boot 将对象转换为json返回

    Spring Boot默认使用Jackson将对象转换为json 需要配置以下依赖 compile group com fasterxml jackson core name jackson core version 2 9 4 compi

  • matlab实现kmeans聚类算法

    kmeans聚类算法是一种简单实用的聚类算法 matlab自带函数kmeans可直接对数据进行kmeans聚类 为了方便更好地掌握kmeans聚类算法 今天我们自己来实现一个弱化的版本mykmeans mykmeans输入包含三项 分别为聚

  • 【数据结构】图-图的遍历_广度优先遍历（动态图解、c++、java）

    文章目录 一 概述 二 广度优先搜索 图解 BFS树 代码 邻接矩阵实现 邻接表实现 链式前向星实现 三 完整代码 邻接矩阵版 邻接表版 链式前向星版 四 总结 算法复杂度分析 基于邻接矩阵的 BFS 算法 基于邻接表的 BFS 算法 注意

热门标签