数据结构与算法-耿国华-图部分的全部代码【C++】

前言

总结整理不易，希望大家点赞收藏。

给大家整理了一下数据结构与算法中图的全部代码，以供大家期末复习和考研复习的时候使用。
参考资料是耿国华的数据结构与算法。

即插即用

邻接表

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<stack>
#include<queue>
#define MAX 20
#define INFINITY 65535//代表正无穷
typedef char VertexData;//顶点数据类型
typedef int EdgeData;//带权图上的权值数据类型
typedef int MatrixAdjType;
using namespace std;
//图的存储结构//邻接表法
typedef struct ArcNode {//弧节点int adjvex;//该弧指向的顶点位置struct ArcNode* nextarc;//指向下一个弧的指针//EDGETYPE info;//权值int weight;
}ArcNode;
typedef struct VertexNode {VertexData data;//顶点数据ArcNode* firstarc;//指向该顶点的第一条弧的指针
}VertexNode;
typedef struct {VertexNode vertexlist[MAX];int vexnum, arcnum;
}AdjList;//求顶点位置函数
int LocateVertex(AdjList* G, VertexData v) {for (int i = 0; i < G->vexnum; i++) {if (G->vertexlist[i].data == v) {return i;}}
}
//创建邻接表
void CreateAdjList(AdjList* g) {int i, j, k, weight;char vi, vj;printf("请输入顶点数和边数：\n");scanf("%d,%d", &g->vexnum, &g->arcnum);for (i = 0; i < g->vexnum; i++) {g->vertexlist[i].data = 'A' + i;g->vertexlist[i].firstarc = NULL;}printf("请输入弧的起点，终点和权值：\n");for (k = 0; k < g->arcnum; k++) {scanf(" %c ,%c,%d", &vi, &vj, &weight);ArcNode* p = (ArcNode*)malloc(sizeof(ArcNode));p->adjvex = LocateVertex(g, vj);p->weight = weight;ArcNode* tmp = g->vertexlist[LocateVertex(g, vi)].firstarc;if (tmp == NULL) {g->vertexlist[LocateVertex(g, vi)].firstarc = p;p->nextarc = NULL;}else {while (tmp->nextarc != NULL) {tmp = tmp->nextarc;}p->nextarc = tmp->nextarc;tmp->nextarc = p;}//无向图有
#if 1ArcNode* s = (ArcNode*)malloc(sizeof(ArcNode));s->adjvex = LocateVertex(g, vi);s->weight = weight;ArcNode* tmp2 = g->vertexlist[LocateVertex(g, vj)].firstarc;if (tmp2 == NULL) {s->nextarc = g->vertexlist[LocateVertex(g, vj)].firstarc;g->vertexlist[LocateVertex(g, vj)].firstarc = s;}else {while (tmp2->nextarc != NULL) {tmp2 = tmp2->nextarc;}s->nextarc = tmp2->nextarc;tmp2->nextarc = s;}
#endif}
}
/*深度优先遍历递归通式
//深度优先遍历v0所在子图
void DepthFirstSearch(Graph g, int v0) {visit(v0);visited[v0] = 1;int w = FirstAdjVertex(g, v0);while (w != -1) {if (!visited[w]) {DepthFirstSearch(g, w);w = NextAdjVertex(g, v0, w);}}
}
//深度优先遍历图
int visited[MAX];
void TraverseGraph(Graph g) {for (int vi = 0; vi < g.vexnum; vi++) {visited[vi] = 0;}for (int vi = 0; vi < g.vexnum; vi++) {if (!visited[vi]) {DepthFirstSearch(g, vi);}}
}
*///邻接表递归实现DFS
int visited[MAX];
void DepthFirstSearch(AdjList g, int v0) {printf("%c ", g.vertexlist[v0].data);visited[v0] = 1;ArcNode* p = g.vertexlist[v0].firstarc;/*while (p != NULL) {if (!visited[p->adjvex]) {DepthFirstSearch(g, p->adjvex);}p = p->nextarc;}*/for (p; p != NULL; p = p->nextarc) {if (!visited[p->adjvex]) {DepthFirstSearch(g, p->adjvex);}}
}
void TraverseGraph(AdjList g) {for (int vi = 0; vi < g.vexnum; vi++) {visited[vi] = 0;}for (int vi = 0; vi < g.vexnum; vi++) {if (!visited[vi]) {DepthFirstSearch(g, vi);}}
}//邻接表非递归实现DFS
void NoReDepthFirstSearch(AdjList g, int v0) {printf("%c ", g.vertexlist[v0].data);//visit(v0);visited[v0] = 1;stack<int>S;S.push(v0);while (!S.empty()) {int top = S.top();ArcNode* p = g.vertexlist[top].firstarc;/*while (p != NULL) {if (!visited[p->adjvex]) {printf("%c ", g.vertexlist[p->adjvex].data);//visit(p->adjvex);visited[p->adjvex] = 1;S.push(p->adjvex);p = p->nextarc;break;}p = p->nextarc;}*/for (p; p != NULL; p = p->nextarc) {if (!visited[p->adjvex]) {printf("%c ", g.vertexlist[p->adjvex].data);//visit(p->adjvex);visited[p->adjvex] = 1;S.push(p->adjvex);break;}}if (p == NULL) {S.pop();}}
}
void NoReTraverseGraph(AdjList g) {for (int vi = 0; vi < g.vexnum; vi++) {visited[vi] = 0;}for (int vi = 0; vi < g.vexnum; vi++) {if (!visited[vi]) {NoReDepthFirstSearch(g, vi);}}
}//邻接表非递归实现BFS
void NoReBroadFirstSearch(AdjList g, int v) {printf("%c ", g.vertexlist[v].data);visited[v] = 1;queue<int>Q;Q.push(v);while (!Q.empty()) {int front = Q.front();ArcNode* p = g.vertexlist[front].firstarc;for (p; p != NULL; p = p->nextarc) {if (!visited[p->adjvex]) {printf("%c ", g.vertexlist[p->adjvex].data);visited[p->adjvex] = 1;Q.push(p->adjvex);}}if (p == NULL) {Q.pop();}}
}
void NoReTraverseGrap(AdjList g) {for (int vi = 0; vi < g.vexnum; vi++) {visited[vi] = 0;}for (int vi = 0; vi < g.vexnum; vi++) {if (!visited[vi]) {NoReBroadFirstSearch(g, vi);}}
}//深度优先找出顶点u和顶点v的简单路径
void FindPath(AdjList g, int vi, int vj, int* path, int d) {visited[vi] = 1;d++;path[d] = vi;if (vi == vj) {int i;for (i = 0; i <= d; i++) {printf("%c ", g.vertexlist[path[i]].data);if (i != 0) {visited[path[i]] = 0;}}printf("\n");return;}ArcNode* p = g.vertexlist[vi].firstarc;while (p != NULL) {for (int len = d; len >= 0; len--) {visited[path[len]] = 1;}if (!visited[p->adjvex]) {FindPath(g, p->adjvex, vj, path, d);}p = p->nextarc;}if (p == NULL) {visited[vi] = 0;d--;}
}//计算入度
void CountIndegree(AdjList g, int* indegree, ArcNode* p) {for (p; p != NULL; p = p->nextarc) {indegree[p->adjvex]++;}return;
}//拓扑排序
bool TopoSort(AdjList g, int* indegree) {for (int i = 0; i < g.vexnum; i++) {indegree[i] = 0;}for (int i = 0; i < g.vexnum; i++) {ArcNode* p = g.vertexlist[i].firstarc;for (p; p != NULL; p = p->nextarc) {indegree[p->adjvex]++;}}stack<int>S;for (int i = 0; i < g.vexnum; i++) {if (indegree[i] == 0) {S.push(i);}}int count = 0;while (!S.empty()) {int top = S.top();printf("%c ", g.vertexlist[top].data);S.pop();count++;ArcNode* p = g.vertexlist[top].firstarc;for (p; p != NULL; p = p->nextarc) {int i = p->adjvex;if (--indegree[i] == 0) {S.push(i);}}}if (count == g.vexnum) {return true;}return false;
}//单源最短路径-迪杰斯特拉算法(带权值）
void ShortestPath(AdjList g, int vi, int* path, int* dist) {int* final = (int*)malloc(sizeof(int) * g.vexnum);for (int i = 0; i < g.vexnum; i++) {path[i] = -1;final[i] = 0;dist[i] = INFINITY;}ArcNode* p = g.vertexlist[vi].firstarc;for (p; p != NULL; p = p->nextarc) {dist[p->adjvex] = p->weight;path[p->adjvex] = vi;}dist[vi] = 0;final[vi] = 1;int k = 0;for (int v = 0; v < g.vexnum - 1; v++) {int min = INFINITY;for (int w = 0; w < g.vexnum; w++) {if (!final[w] && dist[w] < min) {k = w;min = dist[w];}}final[k] = 1;ArcNode* p = g.vertexlist[k].firstarc;for (p; p != NULL; p = p->nextarc) {if (!final[p->adjvex] && (p->weight + min) < dist[p->adjvex]) {dist[p->adjvex] = min + p->weight;path[p->adjvex] = k;}}}for (int i = 0; i < g.vexnum; i++) {if (i != vi) {printf("%c到%c的最短距离为：%d\n", g.vertexlist[vi].data, g.vertexlist[i].data, dist[i]);}}free(final);
}//BFS算法求单源最短路径（不带权值）
void BFS_MIN_Distance(AdjList g, int v) {int* dist = (int*)malloc(sizeof(int) * g.vexnum);for (int i = 0; i < g.vexnum; i++) {visited[i] = 0;}for (int i = 0; i < g.vexnum; i++) {dist[i] = -1;}visited[v] = 1;dist[v] = 0;queue<int>Q;Q.push(v);while (!Q.empty()) {int front = Q.front();ArcNode* p = g.vertexlist[front].firstarc;for (p; p != NULL; p = p->nextarc) {if (!visited[p->adjvex]) {visited[p->adjvex] = 1;dist[p->adjvex] = dist[front] + 1;Q.push(p->adjvex);}}if (p == NULL) {Q.pop();}}for (int i = 0; i < g.vexnum; i++) {if (i != v) {if (dist[i] != -1) {printf("%c到%c的最短路径为%d\n", g.vertexlist[v].data, g.vertexlist[i].data, dist[i]);}}}
}//求距离顶点v0的最短路径长度为K的所有顶点
void FindNodeSetLenPath(AdjList g, int v0, int len) {queue<int>QNode;queue<int>QLevel;for (int i = 0; i < g.vexnum; i++) {visited[i] = 0;}visited[v0] = 1;int level = 0;QNode.push(v0);QLevel.push(level);while (!QNode.empty() && level <= len) {int curnode = QNode.front();level = QLevel.front();if (level == len) {while (!QNode.empty()) {int front = QNode.front();printf("%c ", g.vertexlist[front].data);QNode.pop();}return;}QNode.pop();QLevel.pop();ArcNode* p = g.vertexlist[curnode].firstarc;for (p; p != NULL; p = p->nextarc) {if (!visited[p->adjvex]) {visited[p->adjvex] = 1;QNode.push(p->adjvex);QLevel.push(level + 1);}}}
}void test() {AdjList G;CreateAdjList(&G);printf("递归DFS\n");TraverseGraph(G);printf("\n");printf("非递归DFS\n");NoReTraverseGraph(G);printf("\n");printf("非递归BFS\n");NoReTraverseGrap(G);printf("\n");//输出所有路径
#if 0int* path = (int*)malloc(sizeof(int) * G.vexnum);printf("输入要查询的两个节点,英文逗号隔开\n");char ci, cj;scanf(" %c, %c", &ci, &cj);int vi = LocateVertex(&G, ci);int vj = LocateVertex(&G, cj);for (int i = 0; i < MAX; i++) {visited[i] = 0;}FindPath(G, vi, vj, path, -1);free(path);printf("\n");
#endif//拓朴排序
#if 1//计算入度int* indegree = (int*)malloc(sizeof(int) * G.vexnum);//打印入度for (int i = 0; i < G.vexnum; i++) {indegree[i] = 0;}for (int i = 0; i < G.vexnum; i++) {ArcNode* p = G.vertexlist[i].firstarc;CountIndegree(G, indegree, p);}for (int i = 0; i < G.vexnum; i++) {printf("%c 的入度是 %d\n", G.vertexlist[i].data, indegree[i]);}int ret = TopoSort(G, indegree);printf("\n");if (ret == 1) {printf("拓扑排序成功,为有向无环图\n");}else {printf("拓扑排序失败，图中有环\n");}
#endif//最短路径
#if 0int* path = (int*)malloc(sizeof(G.vexnum));int* dist = (int*)malloc(sizeof(G.vexnum));printf("输入要查询的节点的最短路径\n");char c;scanf(" %c", &c);printf("=======================迪杰斯特拉最短路径算法=====================\n");int vi = LocateVertex(&G, c);ShortestPath(G, 0, path, dist);printf("================================================================\n");
#endif//BFS最短路径
#if 0printf("输入要查询的节点的最短路径\n");char c1;scanf(" %c", &c1);printf("=======================BFS最短路径最短路径算法=====================\n");int vi1 = LocateVertex(&G, c1);BFS_MIN_Distance(G, vi1);printf("================================================================\n");
#endif//求指定距离的所有顶点
#if 0char SetNode = 0;int Setlen = 0;printf("输入起点和距离\n");scanf(" %c", &SetNode);scanf("%d", &Setlen);int SetnodeNum = LocateVertex(&G, SetNode);FindNodeSetLenPath(G, SetnodeNum, Setlen);
#endifreturn;
}int main() {test();return 0;
}

邻接矩阵

这里只放出简单算法，其他的算法参照邻接表，邻接表是重点

#define _CRT_SECURE_NO_WARNINGS#include<stdio.h>
#include<stdlib.h>
#include<stack>
#include<queue>#define MAX 20
#define ZHENGWUQIONG 65535//代表正无穷
#define INFINITY 65535
using namespace std;//邻接矩阵存储结构
typedef char VertexData;//顶点数据类型
typedef int AdjType;//无向图中1/0表示是否相邻，有向图中表示权值
typedef struct ArcNode {AdjType adj;
}ArcNode;
typedef struct {VertexData vertex[MAX];//顶点表ArcNode arcs[MAX][MAX];//边表int vexnum, arcnum;
}AdjMatrix;//求顶点位置函数
int LocateVertex(AdjMatrix* G, VertexData v) {int j, k;for (k = 0; k < G->vexnum; k++) {if (G->vertex[k] == v) {j = k;break;}}return j;
}//建立网图的邻接矩阵表示
void CreateAdjMatrix(AdjMatrix* G) {int i, j, k, weight;VertexData v1, v2;printf("输入顶点数和边数\n");scanf("%d,%d", &G->vexnum, &G->arcnum);//G->vexnum = 8;//G->arcnum = 9;//对边表初始化for (i = 0; i < G->vexnum; i++) {for (j = 0; j < G->vexnum; j++) {G->arcs[i][j].adj = ZHENGWUQIONG;}}//输入顶点表for (i = 0; i < G->vexnum; i++) {G->vertex[i] = 'A' + i;}printf("输入边表及其权值\n");for (k = 0; k < G->arcnum; k++) {scanf(" %c, %c,%d", &v1, &v2, &weight);i = LocateVertex(G, v1);j = LocateVertex(G, v2);G->arcs[i][j].adj = weight;//加上下面这行这就创建无向图。G->arcs[j][i].adj = G->arcs[i][j].adj;}
}int visited[MAX];
//邻接矩阵递归实现DFS
void DepthFirstSearch(AdjMatrix g, int v0) {printf("%c ", g.vertex[v0]);//visit(v0);visited[v0] = 1;for (int vj = 0; vj < g.vexnum; vj++) {if (!visited[vj] && g.arcs[v0][vj].adj != ZHENGWUQIONG) {DepthFirstSearch(g, vj);}}
}
void TraverseGraph(AdjMatrix g) {for (int vi = 0; vi < g.vexnum; vi++) {visited[vi] = 0;}for (int vi = 0; vi < g.vexnum; vi++) {if (!visited[vi]) {DepthFirstSearch(g, vi);}}
}//邻接矩阵非递归实现DFS
void NoReDepthFirstSearch(AdjMatrix g, int v0) {printf("%c ", g.vertex[v0]);//visit(v0);visited[v0] = 1;stack<int>S;S.push(v0);while (!S.empty()) {int top = S.top();int w = 0;for (w = 0; w < g.vexnum; w++) {if (!visited[w] && g.arcs[top][w].adj != ZHENGWUQIONG) {printf("%c ", g.vertex[w]);//visit(w);visited[w] = 1;S.push(w);break;}}if (w == g.vexnum) {S.pop();}}
}
void NoReTraverseGraph(AdjMatrix g) {for (int vi = 0; vi < g.vexnum; vi++) {visited[vi] = 0;}for (int vi = 0; vi < g.vexnum; vi++) {if (!visited[vi]) {NoReDepthFirstSearch(g, vi);}}
}//邻接矩阵非递归实现BFS
void NoReBroadFirstSearch(AdjMatrix g, int v) {printf("%c ", g.vertex[v]);visited[v] = 1;queue<int>Q;Q.push(v);while (!Q.empty()) {int front = Q.front();int i;for (i = 0; i < g.vexnum; i++) {if (!visited[i] && g.arcs[front][i].adj != ZHENGWUQIONG) {printf("%c ", g.vertex[i]);visited[i] = 1;Q.push(i);}}if (i == g.vexnum) {Q.pop();}}
}
void NoReTraverseGrap(AdjMatrix g) {for (int vi = 0; vi < g.vexnum; vi++) {visited[vi] = 0;}for (int vi = 0; vi < g.vexnum; vi++) {if (!visited[vi]) {NoReBroadFirstSearch(g, vi);}}
}//深度优先找出顶点u和顶点v的简单路径
void FindPath(AdjMatrix g, int vi, int vj, int* path, int d) {//d为栈顶元素下标初始为-1；int i;++d;//把vi放到path数组中path[d] = vi;//设置vi为已访问visited[vi] = 1;//如果找到vjif (vi == vj) {int len = d;//弹空path数组for (int j = 0; j <= len; j++) {printf("%c ", g.vertex[path[j]]);if (j != 0) {visited[path[j]] = 0;}}printf("\n");}for (i = 0; i < g.vexnum; i++) {for (int len = d; len >= 0; len--) {visited[path[len]] = 1;}if (!visited[i] && g.arcs[vi][i].adj != ZHENGWUQIONG) {FindPath(g, i, vj, path, d);}}//如果循环完了还没找到就退栈并且设置没访问过。等于走了个死胡同然后退出。if (i == g.vexnum) {visited[vi] = 0;}
}//优化版本
void FindPath2(AdjMatrix g, int vi, int vj, int* path, int d) {//d为栈顶元素下标初始为-1；int i;++d;//把vi放到path数组中path[d] = vi;//设置vi为已访问visited[vi] = 1;//如果找到vjif (vi == vj) {int len = d;//弹空path数组for (int j = 0; j <= len; j++) {printf("%c ", g.vertex[path[j]]);if (j != 0) {visited[path[j]] = 0;}}printf("\n");}for (i = 0; i < g.vexnum; i++) {for (int len = d; len >= 0; len--) {visited[path[len]] = 1;}if (!visited[i] && g.arcs[vi][i].adj != ZHENGWUQIONG) {FindPath(g, i, vj, path, d);}}//如果循环完了还没找到就退栈并且设置没访问过。等于走了个死胡同然后退出。if (i == g.vexnum) {visited[vi] = 0;}
}//普利姆算法（加点法）
struct {int adjvex;int lowcost;
}closedge[MAX];
void PrimMiniSpanTree(AdjMatrix g, int v0) {closedge[v0].lowcost = 0;for (int i = 0; i < g.vexnum; i++) {if (i != v0) {closedge[i].adjvex = v0;closedge[i].lowcost = g.arcs[v0][i].adj;}}for (int i = 0; i < g.vexnum - 1; i++) {int mindist = INFINITY;int minnode = 0;for (int j = 0; j < g.vexnum; j++) {if (closedge[j].lowcost != 0 && closedge[j].lowcost < mindist) {mindist = closedge[j].lowcost;minnode = j;}}printf("(%c,%c) ", g.vertex[closedge[minnode].adjvex], g.vertex[minnode]);closedge[minnode].lowcost = 0;for (int j = 0; j < g.vexnum; j++) {if (closedge[j].lowcost != 0 && g.arcs[minnode][j].adj < closedge[j].lowcost) {closedge[j].lowcost = g.arcs[minnode][j].adj;closedge[j].adjvex = minnode;}}}
}void test() {AdjMatrix G;CreateAdjMatrix(&G);//深度优先遍历printf("深度优先遍历:\n");printf("递归：\n");TraverseGraph(G);printf("\n");printf("非递归：\n");NoReTraverseGraph(G);printf("\n");//广度优先遍历printf("广度优先遍历:\n");NoReTraverseGrap(G);printf("\n");int* path = (int*)malloc(sizeof(int) * G.vexnum);printf("输入要查询的两个节点,英文逗号隔开\n");char ci, cj;scanf(" %c, %c", &ci, &cj);int vi = LocateVertex(&G, ci);int vj = LocateVertex(&G, cj);for (int i = 0; i < MAX; i++) {visited[i] = 0;}FindPath(G, vi, vj, path, -1);free(path);
}
void test01() {AdjMatrix G;CreateAdjMatrix(&G);//深度优先遍历printf("深度优先遍历:\n");printf("递归：\n");TraverseGraph(G);printf("\n");printf("非递归：\n");NoReTraverseGraph(G);printf("\n");printf("输入普利姆算法的顶点\n");int v0 = 0;char c0 = 0;scanf(" %c", &c0);v0 = LocateVertex(&G, c0);PrimMiniSpanTree(G, v0);
}
int main() {test();//test01();return 0;
}

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

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

相关文章

Python爬虫实战第三例【三】（下）

Python爬虫实战第三例【三】（下）

零.前情提要&#xff1a; 没有看上一章的小伙伴&#xff0c;建议先去看上一章&#xff0c;避免有些知识点不连贯 地址&#xff1a;Python爬虫实战第三例【三】【上】-CSDN博客 在上一章&#xff0c;我们经过分析.m3u8文件和.ts文件后&#xff0c;成功爬取到了所有.ts文件的文…
阅读更多...
冒泡经典题

冒泡经典题

&#x1f4d1;前言 本文主要是【】——简单使用的文章&#xff0c;如果有什么需要改进的地方还请大佬指出⛺️ &#x1f3ac;作者简介&#xff1a;大家好&#xff0c;我是听风与他&#x1f947; ☁️博客首页&#xff1a;CSDN主页听风与他 &#x1f304;每日一句&#xff1a;狠…
阅读更多...
RN开发搬砖经验之-Android平台下处理后退按钮事件

RN开发搬砖经验之-Android平台下处理后退按钮事件

基本接口 利用RN 针对Android平台提供的接口 BackHandler BackHandler需要区分类组件跟函数组件的场景&#xff0c;主要是两个组件一个基于组件生命周期的&#xff0c;一个是基于hook的&#xff0c;即注册BackHandler的事件监听与移除时机写法不同。 类组件 示例代码 impor…
阅读更多...
使用J-Link | OPENSDA 调试S32K144开发板

使用J-Link | OPENSDA 调试S32K144开发板

一、S32DS下载 使用的开发软件为S32DS&#xff0c;可以到NXP官网下载&#xff1a;链接&#xff0c;也可以通过网盘&#xff1a;链接 二、对S32K144开发板进行调试 调试方法一&#xff1a; S32K144开发板自带一个OPENSDA MCU&#xff0c;我们可以通过一根Mircro USB线连接到电…
阅读更多...
计算机网络-第3章 数据链路层

计算机网络-第3章 数据链路层

主要内容&#xff1a;两个信道及对应的协议&#xff1a;点对点信道和广播信道&#xff0c;扩展以太网和高速以太网 本章的分组转发为局域网内的转发&#xff0c;不经过路由&#xff0c;网络层分组转为为网络与网络之间的转发&#xff0c;经过路由。局域网属于网络链路层的范围…
阅读更多...
springboot3.x 以上,官方不建议使用spring.factories

springboot3.x 以上,官方不建议使用spring.factories

springboot2.7.x 以上,官方不建议使用spring.factories 最近公司项目升级.需要将springcloud/springboot版本升级到2.7.x以上,再升级的过程中遇到了太多的问题.总结在了如下文章中: springboot艰难版本升级之路!! springboot 2.3.x版本升级到2.7.x版本 这篇文章就重点是梳理一…
阅读更多...
LeetCode 热题 100 (尽量ACM模式刷) 持续更新！！！

LeetCode 热题 100 (尽量ACM模式刷) 持续更新！！！

LeetCode 热题 100 哈希hash 1 两数之和 /** 给定一个整数数组 nums 和一个整数目标值 target&#xff0c;请你在该数组中找出和为目标值target的那两个整数&#xff0c;并返回它们的数组下标。* 你可以假设每种输入只会对应一个答案。但是&#xff0c;数组中同一个元素在答案…
阅读更多...
AWS MSK的连接

AWS MSK的连接

kafka客户端需要Java依赖&#xff0c;所以先安装Java11&#xff0c; sudo yum install java-11https://docs.aws.amazon.com/zh_cn/msk/latest/developerguide/port-info.html 匿名连接 # 匿名使用9092端口 BootstrapServerStringb-2.xxxx.kafka.cn-north-1.amazonaws.com.c…
阅读更多...
品优购首页制作

品优购首页制作

一&#xff0c;常用模块类名命名 二&#xff0c;快捷导航shortcut制作 三&#xff0c;header制作 3.1LOGO SEO优化 3.2 搜索模块定位 四&#xff0c; nav导航制作 五&#xff0c;footer底部制作 六&#xff0c;main主体模块制作 以前书写是模块化中的公共部分 main主体模块是…
阅读更多...
MyBatis介绍

MyBatis介绍

MyBatis是一个优秀的持久层框架&#xff08;就是将某些数据持久化到硬盘或其他存储器中的框架&#xff09;&#xff0c;它把jdbc对数据库的操作进行了封装&#xff0c;使用户只需关注sql本身&#xff0c;不需要去执行jdbc的那一套复杂的操作。 MyBatis通过配置xml文件或注解的方…
阅读更多...
Linux安全加固功能

Linux安全加固功能

提示:工具下载链接在文章最后 目录 一.加固功能介绍二.配置加固功能1.配置安全加固功能1.1 开放目前设备监听的所有端口1.2 只开放80、443、20、21、22端口1.3 防火墙配置工具1.3.1 开放允许访问的端口1.3.2 删除允许访问的端口1.3.3 添加IP地址允许访问规则1.3.4 添加IP地址禁…
阅读更多...
漫画手绘视频教程分享

漫画手绘视频教程分享

下载地址&#xff1a; 漫画手绘教程: https://url83.ctfile.com/d/45573183-60305653-039aed?p7526 (访问密码: 7526)
阅读更多...
JavaScript基础3之面向对象关于面向过程、函数式编程、对比、构造函数、原型

JavaScript基础3之面向对象关于面向过程、函数式编程、对比、构造函数、原型

JavaScript基础 面向对象面向过程函数式编程命令式编程函数式编程特性副作用透明引用不可变变量函数是一等公民 常见的函数式编程模型 面向对象为什么要使用面向对象封装继承多态 对比面向过程函数式编程面向对象 构造函数原型constructor使用场景 对象原型 面向对象 面向过程…
阅读更多...
chrome自动更新后，手动恢复书签和历史记录

chrome自动更新后，手动恢复书签和历史记录

本文是针对google没有登录账号信息&#xff0c;浏览器更新后&#xff0c;如何恢复本地书签可历史记录。 为了解决“已被CORS策略阻止&#xff1a;请求的资源上没有’Access-Control-Allow-Origin’标头&#xff08;跨域请求失败”这个问题&#xff0c;修改了Google属性&#x…
阅读更多...
【C语言】算术运算符

【C语言】算术运算符

C语言算术运算符&#xff0c;加、减、乘、比较简单&#xff0c;主要需要注意有除法和取余两个&#xff0c;以及前自增和前自增&#xff0c;减法类似。 运算符 术语 示例 结果 加 10 5 15 - 减 10 - 5 5 * 乘 10 * 5 50 / 除 10 / 5 2 % 取模(取余) 10 …
阅读更多...
数据结构试题

数据结构试题

一、选择题 01.可以用( D )定义一个完整的数据结构。 A.数据元素 B&#xff0e;数据对象 C&#xff0e;数据关系 D.抽象数据类型 02.以下数据结构中&#xff0c;( A )是非线性数据结构。 A.树 B.字符串 …
阅读更多...
android开发教程视频，android组件化和插件化

android开发教程视频，android组件化和插件化

第一阶段&#xff1a;Android 基础知识回顾&#xff1a; 回顾Android 开发编程&#xff0c;深入理解Android系统原理和层次结构&#xff0c;深入分析Handler源码和原理&#xff1b;回顾Java&#xff0c;C/C&#xff0c;Kotlin、dart 在Android开发中必用的语言&#xff0c;熟悉…
阅读更多...
Python中的collections模块

Python中的collections模块

Python中的collections模块 文章目录 Python中的collections模块1.Counter对象2.deque对象3.defaultdict对象4.namedtuple5.OrderedDictReference Python中的 collections提供许多容器数据类型&#xff0c;这个模块实现了一些专门化的容器&#xff0c;提供了对Python的通用内建…
阅读更多...
算法学习03：前缀和与差分（互逆）

算法学习03：前缀和与差分（互逆）

算法学习03&#xff1a;前缀和与差分&#xff08;互逆&#xff09; 文章目录 算法学习03&#xff1a;前缀和与差分&#xff08;互逆&#xff09;前言一、前缀和1.一维2.二维 二、差分1.一维在这里插入图片描述2.二维在这里插入图片描述 ![在这里插入图片描述](https://img-blog…
阅读更多...
YoloV7改进策略：主干网络改进|MogaNet——高效的多阶门控聚合网络

YoloV7改进策略：主干网络改进|MogaNet——高效的多阶门控聚合网络

文章目录 摘要论文：《MogaNet——高效的多阶门控聚合网络》1、简介2、相关工作2.1、视觉Transformers2.2、ViT时代的卷积网络3、从多阶博弈论交互的角度看表示瓶颈4、方法论4.1、MogaNet概述4.2、多阶门控聚合4.3、通过通道聚合进行多阶特征重新分配4.4、实现细节5、实验5.1、…
阅读更多...
最新文章

Copyright @ 2022~2023