数据结构与算法：图

文章目录

  • 图
      • 1) 概念
        • 有向 vs 无向
        • 度
        • 权
        • 路径
        • 环
        • 图的连通性
      • 2) 图的表示
      • 3) Java 表示
      • 4) DFS
      • 5) BFS
      • 6) 拓扑排序
      • 7) 最短路径
        • Dijkstra
        • Bellman-Ford
        • Floyd-Warshall
      • 8) 最小生成树
        • Prim
        • Kruskal

图

1) 概念

图是由顶点（vertex）和边（edge）组成的数据结构，例如
A
B
C
D

该图有四个顶点：A、B、C、D 以及四条有向边，有向图中，边是单向的

有向 vs 无向

如果是无向图，那么边是双向的，下面是一个无向图的例子
A
B
C
D
度

度是指与该顶点相邻的边的数量
A
B
C
D
E
F

例如上图中

  • A、B、C、E、F 这几个顶点度数为 2
  • D 顶点度数为 4

有向图中，细分为入度和出度，参见下图
A
B
C
D
E
F
  • A (2 out / 0 in)
  • B、C、E (1 out / 1 in)
  • D (2 out / 2 in)
  • F (0 out / 2 in)
权

边可以有权重，代表从源顶点到目标顶点的距离、费用、时间或其他度量。
北京
武汉
广州
上海
800km
1900km
1200km
1050km
700km
路径

路径被定义为从一个顶点到另一个顶点的一系列连续边，例如上图中【北京】到【上海】有多条路径

  • 北京 - 上海
  • 北京 - 武汉 - 上海

路径长度

  • 不考虑权重，长度就是边的数量
  • 考虑权重，一般就是权重累加
环

在有向图中，从一个顶点开始，可以通过若干条有向边返回到该顶点，那么就形成了一个环
A
B
C
D
E
图的连通性

如果两个顶点之间存在路径，则这两个顶点是连通的，所有顶点都连通，则该图被称之为连通图，若子图连通，则称为连通分量
A
B
C
D
E
F
G
H
I
J

2) 图的表示

比如说，下面的图
A
B
C
D

用邻接矩阵可以表示为：

  A B C D
A 0 1 1 0
B 1 0 0 1 
C 1 0 0 1
D 0 1 1 0

用邻接表可以表示为：

A -> B -> C
B -> A -> D
C -> A -> D
D -> B -> C

有向图的例子
A
B
C
D 
  A B C D
A 0 1 1 0
B 0 0 0 1
C 0 0 0 1
D 0 0 0 0

A - B - C
B - D
C - D
D - empty

3) Java 表示

顶点

public class Vertex {String name;List<Edge> edges;// 拓扑排序相关int inDegree;int status; // 状态 0-未访问 1-访问中 2-访问过，用在拓扑排序// dfs, bfs 相关boolean visited;// 求解最短距离相关private static final int INF = Integer.MAX_VALUE;int dist = INF;Vertex prev = null;@Overridepublic String toString() {return this.name;}
}

边

public class Edge {Vertex linked;int weight;public Edge(Vertex linked) {this(linked, 1);}public Edge(Vertex linked, int weight) {this.linked = linked;this.weight = weight;}
}

4) DFS

public class Dfs {public static void main(String[] args) {Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");Vertex v5 = new Vertex("v5");Vertex v6 = new Vertex("v6");v1.edges = List.of(new Edge(v3), new Edge(v2), new Edge(v6));v2.edges = List.of(new Edge(v4));v3.edges = List.of(new Edge(v4), new Edge(v6));v4.edges = List.of(new Edge(v5));v5.edges = List.of();v6.edges = List.of(new Edge(v5));dfs1(v1);}private static void dfs2(Vertex v) {LinkedList<Vertex> stack = new LinkedList<>();stack.push(v);while (!stack.isEmpty()) {Vertex pop = stack.pop();pop.visited = true;System.out.println(pop.name);for (Edge edge : pop.edges) {if (!edge.linked.visited) {stack.push(edge.linked);}}}}private static void dfs1(Vertex v) {v.visited = true;System.out.println(v.name);for (Edge edge : v.edges) {if (!edge.linked.visited) {dfs(edge.linked);}}}
}

5) BFS

public class Bfs {public static void main(String[] args) {Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");Vertex v5 = new Vertex("v5");Vertex v6 = new Vertex("v6");v1.edges = List.of(new Edge(v3), new Edge(v2), new Edge(v6));v2.edges = List.of(new Edge(v4));v3.edges = List.of(new Edge(v4), new Edge(v6));v4.edges = List.of(new Edge(v5));v5.edges = List.of();v6.edges = List.of(new Edge(v5));bfs(v1);}private static void bfs(Vertex v) {LinkedList<Vertex> queue = new LinkedList<>();v.visited = true;queue.offer(v);while (!queue.isEmpty()) {Vertex poll = queue.poll();System.out.println(poll.name);for (Edge edge : poll.edges) {if (!edge.linked.visited) {edge.linked.visited = true;queue.offer(edge.linked);}}}}
}

6) 拓扑排序
网页基础
Java Web
Java 基础
数据库
Spring框架
微服务框架
实战项目 
public class TopologicalSort {public static void main(String[] args) {Vertex v1 = new Vertex("网页基础");Vertex v2 = new Vertex("Java基础");Vertex v3 = new Vertex("JavaWeb");Vertex v4 = new Vertex("Spring框架");Vertex v5 = new Vertex("微服务框架");Vertex v6 = new Vertex("数据库");Vertex v7 = new Vertex("实战项目");v1.edges = java.util.List.of(new Edge(v3)); // +1v2.edges = java.util.List.of(new Edge(v3)); // +1v3.edges = java.util.List.of(new Edge(v4));v6.edges = java.util.List.of(new Edge(v4));v4.edges = java.util.List.of(new Edge(v5));v5.edges = java.util.List.of(new Edge(v7));v7.edges = java.util.List.of();List<Vertex> graph = java.util.List.of(v1,v2,v3,v4,v5,v6,v7);for (Vertex vertex : graph) {for (Edge edge : vertex.edges) {edge.linked.inDegree += 1;}}List<Vertex> result = new ArrayList<>();Stack<Vertex> stack = new Stack<>();for (Vertex vertex : graph) {if(vertex.inDegree == 0 ){stack.push(vertex);}}while(!stack.isEmpty()){Vertex pop = stack.pop();result.add(pop);for (Edge edge : pop.edges) {edge.linked.inDegree--;if(edge.linked.inDegree == 0 && !edge.linked.visited){stack.add(edge.linked);edge.linked.visited = true;}}}if(result.size() != graph.size()){System.out.println("发现环");}for (Vertex vertex : result) {System.out.println(vertex);}}

7) 最短路径

Dijkstra
7
9
14
9
2
15
11
6
1
2
3
4
5
6

算法描述：

  1. 将所有顶点标记为未访问。创建一个未访问顶点的集合。
  2. 为每个顶点分配一个临时距离值
    • 对于我们的初始顶点，将其设置为零
    • 对于所有其他顶点，将其设置为无穷大。
  3. 每次选择最小临时距离的未访问顶点，作为新的当前顶点
  4. 对于当前顶点，遍历其所有未访问的邻居，并更新它们的临时距离为更小
    • 例如，1->6 的距离是 14，而1->3->6 的距离是11。这时将距离更新为 11
    • 否则，将保留上次距离值
  5. 当前顶点的邻居处理完成后，把它从未访问集合中删除
public class Dijkstra {public static void main(String[] args) {Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");Vertex v5 = new Vertex("v5");Vertex v6 = new Vertex("v6");v1.edges = List.of(new Edge(v3, 9), new Edge(v2, 7), new Edge(v6, 14));v2.edges = List.of(new Edge(v4, 15));v3.edges = List.of(new Edge(v4, 11), new Edge(v6, 2));v4.edges = List.of(new Edge(v5, 6));v5.edges = List.of();v6.edges = List.of(new Edge(v5, 9));List<Vertex> graph = List.of(v1, v2, v3, v4, v5, v6);dijkstra(graph, v1);}private static void dijkstra(List<Vertex> graph, Vertex source) {ArrayList<Vertex> list = new ArrayList<>(graph);source.dist = 0;while (!list.isEmpty()) {// 3. 选取当前顶点Vertex curr = chooseMinDistVertex(list);// 4. 更新当前顶点邻居距离updateNeighboursDist(curr, list);// 5. 移除当前顶点list.remove(curr);}for (Vertex v : graph) {System.out.println(v.name + " " + v.dist);}}private static void updateNeighboursDist(Vertex curr, ArrayList<Vertex> list) {for (Edge edge : curr.edges) {Vertex n = edge.linked;if (list.contains(n)) {int dist = curr.dist + edge.weight;if (dist < n.dist) {n.dist = dist;}}}}private static Vertex chooseMinDistVertex(ArrayList<Vertex> list) {Vertex min = list.get(0);for (int i = 1; i < list.size(); i++) {if (list.get(i).dist < min.dist) {min = list.get(i);}}return min;}}

改进 - 优先级队列

  1. 创建一个优先级队列，放入所有顶点（队列大小会达到边的数量）
  2. 为每个顶点分配一个临时距离值
    • 对于我们的初始顶点，将其设置为零
    • 对于所有其他顶点，将其设置为无穷大。
  3. 每次选择最小临时距离的未访问顶点，作为新的当前顶点
  4. 对于当前顶点，遍历其所有未访问的邻居，并更新它们的临时距离为更小，若距离更新需加入队列
    • 例如，1->6 的距离是 14，而1->3->6 的距离是11。这时将距离更新为 11
    • 否则，将保留上次距离值
  5. 当前顶点的邻居处理完成后，把它从队列中删除
public class DijkstraPriorityQueue {public static void main(String[] args) {Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");Vertex v5 = new Vertex("v5");Vertex v6 = new Vertex("v6");v1.edges = List.of(new Edge(v3, 9), new Edge(v2, 7), new Edge(v6, 14));v2.edges = List.of(new Edge(v4, 15));v3.edges = List.of(new Edge(v4, 11), new Edge(v6, 2));v4.edges = List.of(new Edge(v5, 6));v5.edges = List.of();v6.edges = List.of(new Edge(v5, 9));List<Vertex> graph = List.of(v1, v2, v3, v4, v5, v6);dijkstra(graph, v1);}private static void dijkstra(List<Vertex> graph, Vertex source) {PriorityQueue<Vertex> queue = new PriorityQueue<>(Comparator.comparingInt(v -> v.dist));source.dist = 0;for (Vertex v : graph) {queue.offer(v);}while (!queue.isEmpty()) {System.out.println(queue);// 3. 选取当前顶点Vertex curr = queue.poll();// 4. 更新当前顶点邻居距离if(!curr.visited) {updateNeighboursDist(curr, queue);curr.visited = true;}// 5. 移除当前顶点}for (Vertex v : graph) {System.out.println(v.name + " " + v.dist + " " + (v.prev != null ? v.prev.name : "null"));}}private static void updateNeighboursDist(Vertex curr, PriorityQueue<Vertex> queue) {for (Edge edge : curr.edges) {Vertex n = edge.linked;if (!n.visited) {int dist = curr.dist + edge.weight;if (dist < n.dist) {n.dist = dist;n.prev = curr;queue.remove(n); // 先删除再添加才能改变优先级queue.offer(n);}}}}}

问题

2
1
-2
1
v1
v2
v3
v4

按照 Dijkstra 算法，得出

  • v1 -> v2 最短距离2
  • v1 -> v3 最短距离1
  • v1 -> v4 最短距离2

事实应当是

  • v1 -> v2 最短距离2
  • v1 -> v3 最短距离0
  • v1 -> v4 最短距离1
Bellman-Ford
public class BellmanFord {public static void main(String[] args) {// 正常情况/*Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");Vertex v5 = new Vertex("v5");Vertex v6 = new Vertex("v6");v1.edges = List.of(new Edge(v3, 9), new Edge(v2, 7), new Edge(v6, 14));v2.edges = List.of(new Edge(v4, 15));v3.edges = List.of(new Edge(v4, 11), new Edge(v6, 2));v4.edges = List.of(new Edge(v5, 6));v5.edges = List.of();v6.edges = List.of(new Edge(v5, 9));List<Vertex> graph = List.of(v4, v5, v6, v1, v2, v3);*/// 负边情况/*Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");v1.edges = List.of(new Edge(v2, 2), new Edge(v3, 1));v2.edges = List.of(new Edge(v3, -2));v3.edges = List.of(new Edge(v4, 1));v4.edges = List.of();List<Vertex> graph = List.of(v1, v2, v3, v4);*/// 负环情况Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");v1.edges = List.of(new Edge(v2, 2));v2.edges = List.of(new Edge(v3, -4));v3.edges = List.of(new Edge(v4, 1), new Edge(v1, 1));v4.edges = List.of();List<Vertex> graph = List.of(v1, v2, v3, v4);bellmanFord(graph, v1);}private static void bellmanFord(List<Vertex> graph, Vertex source) {source.dist = 0;int size = graph.size();// 1. 进行 顶点个数 - 1 轮处理for (int i = 0; i < size - 1; i++) {// 2. 遍历所有的边for (Vertex s : graph) {for (Edge edge : s.edges) {// 3. 处理每一条边Vertex e = edge.linked;if (s.dist != Integer.MAX_VALUE && s.dist + edge.weight < e.dist) {e.dist = s.dist + edge.weight;e.prev = s;}}}}for (Vertex v : graph) {System.out.println(v + " " + (v.prev != null ? v.prev.name : "null"));}}
}

负环

2
-4
1
1
v1
v2
v3
v4

如果在【顶点-1】轮处理完成后，还能继续找到更短距离，表示发现了负环

Floyd-Warshall
-2
4
3
2
-1
v1
v3
v2
v4 
public class FloydWarshall {public static void main(String[] args) {Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");v1.edges = List.of(new Edge(v3, -2));v2.edges = List.of(new Edge(v1, 4), new Edge(v3, 3));v3.edges = List.of(new Edge(v4, 2));v4.edges = List.of(new Edge(v2, -1));List<Vertex> graph = List.of(v1, v2, v3, v4);/*直接连通v1  v2  v3  v4v1  0   ∞   -2  ∞v2  4   0   3   ∞v3  ∞   ∞   0   2v4  ∞   -1  ∞   0k=0 借助v1到达其它顶点v1  v2  v3  v4v1  0   ∞   -2  ∞v2  4   0   2   ∞v3  ∞   ∞   0   2v4  ∞   -1  ∞   0k=1 借助v2到达其它顶点v1  v2  v3  v4v1  0   ∞   -2  ∞v2  4   0   2   ∞v3  ∞   ∞   0   2v4  3   -1  1   0k=2 借助v3到达其它顶点v1  v2  v3  v4v1  0   ∞   -2  0v2  4   0   2   4v3  ∞   ∞   0   2v4  3   -1  1   0k=3 借助v4到达其它顶点v1  v2  v3  v4v1  0   -1   -2  0v2  4   0   2   4v3  5   1   0   2v4  3   -1  1   0*/floydWarshall(graph);}private static void floydWarshall(List<Vertex> graph){int size = graph.size();int[][] dist = new int[size][size];for (int i = 0; i < size; i++) {  // 初始化Vertex vertex = graph.get(i);Map<Vertex, Integer> collect = vertex.edges.stream().collect(Collectors.toMap(v -> v.linked, v -> v.weight));for (int i1 = 0; i1 < size; i1++) {if(i == i1){dist[i][i1] = 0;continue;}dist[i][i1] = collect.getOrDefault(graph.get(i1),Integer.MAX_VALUE);}}for (int k = 0; k < size; k++) {for (int j = 0; j < size; j++) {int dist1;if((dist1 = dist[j][k]) < Integer.MAX_VALUE){for (int i = 0; i < size; i++) {int dist2;if((dist2 = dist[k][i]) != Integer.MAX_VALUE)dist[j][i] = Integer.min(dist1 + dist2,dist[j][i]);}}}}for (int[] ints : dist) {for (int anInt : ints) {System.out.print(anInt + " ");}System.out.println();}}
}

负环

如果在 3 层循环结束后，在 dist 数组的对角线处（i==j 处）发现了负数，表示出现了负环

8) 最小生成树

图的最小生成树是一个子图，它是连通的，包含图中所有的顶点，并且所有边的权重之和最小。在最小生成树中，没有任何一条边可以被其他边替换而使得总权重变小。也就是说，最小生成树是图的所有生成树中，边的权值总和最小的生成树。

请添加图片描述

解决最小生成树问题的常用算法有Prim算法和Kruskal算法。Prim算法从一个顶点开始，每次都添加一条与当前子图连接的权重最小的边，直到所有顶点都被包含在子图中。Kruskal算法则是从所有的边开始，每次都添加一条当前所有边中权重最小的边，但需要保证添加的边不会形成环，直到所有顶点都被连接。

Prim
public class Prim {public static void main(String[] args) {Vertex v1 = new Vertex("v1");Vertex v2 = new Vertex("v2");Vertex v3 = new Vertex("v3");Vertex v4 = new Vertex("v4");Vertex v5 = new Vertex("v5");Vertex v6 = new Vertex("v6");Vertex v7 = new Vertex("v7");v1.edges = List.of(new Edge(v2, 2), new Edge(v3, 4), new Edge(v4, 1));v2.edges = List.of(new Edge(v1, 2), new Edge(v4, 3), new Edge(v5, 10));v3.edges = List.of(new Edge(v1, 4), new Edge(v4, 2), new Edge(v6, 5));v4.edges = List.of(new Edge(v1, 1), new Edge(v2, 3), new Edge(v3, 2),new Edge(v5, 7), new Edge(v6, 8), new Edge(v7, 4));v5.edges = List.of(new Edge(v2, 10), new Edge(v4, 7), new Edge(v7, 6));v6.edges = List.of(new Edge(v3, 5), new Edge(v4, 8), new Edge(v7, 1));v7.edges = List.of(new Edge(v4, 4), new Edge(v5, 6), new Edge(v6, 1));List<Vertex> graph = List.of(v1, v2, v3, v4, v5, v6, v7);prim(graph, v1);}static void prim(List<Vertex> graph, Vertex source) {ArrayList<Vertex> list = new ArrayList<>(graph);source.dist = 0;while (!list.isEmpty()) {Vertex min = chooseMinDistVertex(list);updateNeighboursDist(min);list.remove(min);min.visited = true;System.out.println("---------------");for (Vertex v : graph) {System.out.println(v);}}}private static void updateNeighboursDist(Vertex curr) {for (Edge edge : curr.edges) {Vertex n = edge.linked;if (!n.visited) {int dist = edge.weight;if (dist < n.dist) {n.dist = dist;n.prev = curr;}}}}private static Vertex chooseMinDistVertex(ArrayList<Vertex> list) {Vertex min = list.get(0);for (int i = 1; i < list.size(); i++) {if (list.get(i).dist < min.dist) {min = list.get(i);}}return min;}
}
Kruskal
  private static void kruskal(List<Vertex> graph,Vertex v1){List<Edge> edges = new ArrayList<>();List<Vertex> pre = new ArrayList<>();for (Vertex vertex : graph) {for (Edge edge : vertex.edges) {edges.add(edge);pre.add(vertex);}}for (int i = 0; i < edges.size(); i++) {Edge minEdge = edges.get(i);int min = minEdge.weight;for (int j = i + 1 ; j < edges.size(); j++) {Edge e = edges.get(j);if(minEdge.weight > e.weight){edges.set(j,minEdge);minEdge = e;edges.set(i,e);Vertex v = pre.get(i);pre.set(i,pre.get(j));pre.set(j,v);}}}List<Vertex> used = new ArrayList<>();for (int i = 0; i < edges.size(); i++) {Vertex v = pre.get(i);Vertex e = edges.get(i).linked;if(!used.contains(v) || !used.contains(e)){System.out.println(v.name + " -> " + e.name);used.add(v);used.add(e);}}
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/638881.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

js提取截图中的中文

js提取截图中的中文

从图片中提取中文 安装依赖 npm install tesseract.js 编写代码(ocr_example.js) const Tesseract require(tesseract.js); const path require(path); const imagePath path.resolve(__dirname, path/image); Tesseract.recognize(imagePath,chi_sim, { logger: m >…
阅读更多...
Mysql学习笔记系列（一）

Mysql学习笔记系列（一）

本次mysql系列不会讲解具体的查询语句&#xff0c;而是放在mysql的一些性能优化和一些特性上&#xff0c;是学习笔记&#xff0c;供大家参考补充。 慢查询 MySQL的慢查询&#xff0c;全名是慢查询日志&#xff0c;是MySQL提供的一种日志记录&#xff0c;用来记录在MySQL中响应…
阅读更多...
P8761 [蓝桥杯 2021 国 BC] 大写

P8761 [蓝桥杯 2021 国 BC] 大写

[蓝桥杯 2021 国 BC] 大写 题目描述 给定一个只包含大写字母和小写字母的字符串&#xff0c;请将其中所有的小写字母转换成大写字母后将字符串输出。 输入格式 输入一行包含一个字符串。 输出格式 输出转换成大写后的字符串。 样例 #1 样例输入 #1 LanQiao样例输出 #1…
阅读更多...
Meta 标签的力量：如何利用它们提高网站的可见性（上）

Meta 标签的力量：如何利用它们提高网站的可见性（上）

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
解决 Navicat 在笔记本外接显示器分辨率自适应展示问题

解决 Navicat 在笔记本外接显示器分辨率自适应展示问题

前言 有时候我们使用自己的笔记本电脑会外接一个显示器&#xff0c;但是显示器的分辨率和笔记本又不一样&#xff0c;所以就会导致 Navicat 基于分辨率的问题变得字体很小。具体操作可点击这里&#xff1a; Navicat 分辨率调整
阅读更多...
如何在ubuntu22.04安装ROS2

如何在ubuntu22.04安装ROS2

ubuntu22.04安装ROS2 教程 选择对应版本进行安装设置编码添加源安装ROS2设置环境变量 运行ROS2 选择对应版本 通过官方网站&#xff0c;查询Ubuntu与ros对应的版本&#xff0c;版本不一致也会出现安装不成功。 https://wiki.ros.org/ROS/Installation 每一个都可以进行点击&a…
阅读更多...
判断子序列

判断子序列

给定字符串 s 和 t &#xff0c;判断 s 是否为 t 的子序列。 字符串的一个子序列是原始字符串删除一些&#xff08;也可以不删除&#xff09;字符而不改变剩余字符相对位置形成的新字符串。&#xff08;例如&#xff0c;"ace"是"abcde"的一个子序列&#…
阅读更多...
解决电脑文件大小写不敏感问题

解决电脑文件大小写不敏感问题

第一步&#xff1a;以管理员的身份运行 CMD 第二步&#xff1a; 输入下面命令 fsutil file setCaseSensitiveInfo 路径 enable 路径改成目标文件夹的路径&#xff0c;比如说我也下面 Less-24 这个文件夹里面的文件全部都大小写敏感 这样就 OK 了&#xff0c;注意路径最后要加…
阅读更多...
python中三种常用格式化字符串的方法(%s, format,f-string)

python中三种常用格式化字符串的方法(%s, format,f-string)

前言 python中对字符串格式化是最常见的操作&#xff0c;对字符串格式化一般有三种方法&#xff0c;即%s,format和f-string。因人而异&#xff0c;每个人使用的格式化方法不同&#xff0c;为了在不同场景更高效的使用格式化方法&#xff0c;以及阅读别人的代码&#xff0c;通常…
阅读更多...
GitFlow工作流

GitFlow工作流

基于 Git 这一版本控制系统&#xff0c;通过定义不同的分支&#xff0c;探索合适的工作流程来完成开发、测试、修改等方面的需求。 例如&#xff1a;在开发阶段&#xff0c;创建 feature 分支&#xff0c;完成需求后&#xff0c;将此分支合并到 develop 分支上&#xff1b;在发…
阅读更多...
深度学习常用代码总结(k-means, NMS)

深度学习常用代码总结(k-means, NMS)

目录 一、k-means 算法 二、NMS 一、k-means 算法 k-means 是一种无监督聚类算法&#xff0c;常用的聚类算法还有 DBSCAN。k-means 由于其原理简单&#xff0c;可解释强&#xff0c;实现方便&#xff0c;收敛速度快&#xff0c;在数据挖掘、数据分析、异常检测、模式识别、金…
阅读更多...
Spring最常用组件注册注解开发案例

Spring最常用组件注册注解开发案例

Spring常用组件注册注解开发案例 文章目录 Spring常用组件注册注解开发案例1. 组件注册注解1. Configuration2.Bean注解3. Configuration与Bean注解使用案例4. ComponentScan注解5. 自定义TypeFilter指定过滤规则 什么是spring注解开发&#xff1f; 就是不再使用Spring的bean.x…
阅读更多...
PHP+vue+Mysql家庭理财管理系统演5x6nf

PHP+vue+Mysql家庭理财管理系统演5x6nf

本文着重阐述了收支管理系统的分析、设计与实现&#xff0c;首先介绍开发系统和环境配置、数据库的设计&#xff0c;对系统的功能需求作出分析&#xff0c;根据需求对系统进行设计&#xff0c;明确各个部分的规范&#xff0c;来完成系统的设计。最后在对设计的系统进行一系列的…
阅读更多...
k8s1.27.2版本二进制高可用集群部署

k8s1.27.2版本二进制高可用集群部署

文章目录 环境软件版本服务器系统初始化设置关于etcd签名证书etcd集群部署负载均衡器组件安装设置关于k8s自签证书自签CAkube-apiserver 自签证书kube-controller-manager自签证书kube-scheduler自签证书kube-proxy 自签证书admin 自签证书 控制平面节点组件部署**部署kube-api…
阅读更多...
前端开发领域的细分领域与特点

前端开发领域的细分领域与特点

前端开发领域是一个广泛而多样的领域&#xff0c;包括了许多具体的细分领域。本文将介绍前端领域的细分领域&#xff0c;包括Web前端、移动端、桌面端、游戏端和VR/AR前端等&#xff0c;并分析它们各自的特点&#xff0c;以帮助读者更好地了解前端开发的多样性。 一、引言 前…
阅读更多...
【python学习】面向对象编程3

【python学习】面向对象编程3

面向对象基础 面向对象编程 面向过程编程&#xff1a;类似于工厂的流水线。 优点&#xff1a;逻辑清晰&#xff1b; 缺点&#xff1a;扩展性差。 面向对象编程&#xff1a;核心是对象二字&#xff0c;对象是属性和方法的集合体&#xff0c;面向对象编程就是一堆对象交互。 优…
阅读更多...
Spring 事务原理一

Spring 事务原理一

从本篇博客开始&#xff0c;我们将梳理Spring事务相关的知识点。在开始前&#xff0c;想先给自己定一个目标&#xff1a;通过此次梳理要完全理解事务的基本概念及Spring实现事务的基本原理。为实现这个目标我想按以下几个步骤进行&#xff1a; 讲解事务中的一些基本概念使用Sp…
阅读更多...
x-cmd pkg | jq - 命令行 JSON 处理器

x-cmd pkg | jq - 命令行 JSON 处理器

目录 简介首次用户功能特点类似工具进一步探索 简介 jq 是轻量级的 JSON 处理工具&#xff0c;由 Stephen Dolan 于 2012 年使用 C 语言开发。 它的功能极为强大&#xff0c;语法简洁&#xff0c;可以灵活高效地完成从 JSON 数据中提取特定字段、过滤和排序数据、执行复杂的转…
阅读更多...
Java NIO （三）NIO Channel类

Java NIO （三）NIO Channel类

1 概述 前面提到&#xff0c;Java NIO中一个socket连接使用一个Channel来表示。从更广泛的层面来说&#xff0c;一个通道可以表示一个底层的文件描述符&#xff0c;例如硬件设备、文件、网络连接等。然而&#xff0c;远不止如此&#xff0c;Java NIO的通道可以更加细化。例如&a…
阅读更多...
在react中说说对受控组件和非受控组件的理解？以及应用场景

在react中说说对受控组件和非受控组件的理解？以及应用场景

在react中说说对受控组件和非受控组件的理解&#xff1f;以及应用场景 回答思路&#xff1a;说说受控组件-->说说非受控组件-->应用场景受控组件&#xff1a;非受控组件应用场景 回答思路&#xff1a;说说受控组件–>说说非受控组件–>应用场景 受控组件&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023