数据结构上机实验——图的实现（以无向邻接表为例）、图的深度优先搜索（DFS）、图的广度优先搜索（BFS）

news2025/1/12 12:00:39

文章目录

  • 数据结构上机实验
    • 1.要求
    • 2.图的实现（以无向邻接表为例）
      • 2.1创建图
        • 2.1.1定义图的顶点、边及类定义
        • 2.1.2创建无向图和查找
        • 2.1.3插入边
        • 2.1.4打印函数
      • 2.2图的深度优先搜索（DFS）
      • 2.3图的广度优先搜索（BFS）
    • 3.全部源码
      • 测试：
      • Graph.h
      • test.cpp

数据结构上机实验

1.要求

  图采用邻接表存储结构，编程实现图的深度优先搜索和广度优先搜索算法。
            

2.图的实现（以无向邻接表为例）

2.1创建图

2.1.1定义图的顶点、边及类定义

  我们定义一个邻接表类（ALGraph）。这里实现一些基础的数据结构。要注意结构体的嵌套。

  Edge: 用于表示图中的边，包含两个顶点（tail和head）和一个权重cost。

  ArcNode: 用于表示图中的有向边，包含一个目标顶点adjvex、一个权重info和一个指向下一个有向边的指针nextarc。

  VNode: 用于表示图中的顶点，包含一个数据值data和一个指向第一条边的指针fistarc。

  AdjGraph: 用于表示整个图，包含一个顶点数组表vertices（最大顶点数为MAXVex）、顶点数vexnum、边数arcnum和图的类型kind。

#define MAXVex 20 //最大的顶点数	
#define VElemType int

typedef enum {
	DG,    //有向图
	UDG,   //无向图
	DN,    //有向网
	UDN    //无向网
}GraphKind;

//定义边
typedef struct 
{
	VElemType tail;
	VElemType head;
	int cost;
}Edge;

//定义边节点
typedef struct ArcNode 
{
	int adjvex;	 //终点在数组表中的下表
	int info;	 //权值
	ArcNode* nextarc; //下一个边的地址
}ArcNode;

//定义表头节点
typedef struct
{
	VElemType data;	 
	ArcNode* fistarc; //储存第一条边的结点地址
}VNode;

//定义邻接表
typedef struct
{
	VNode vertices[MAXVex]; //储存MAXVex个VNode的数组表
	int vexnum;    //顶点数
	int arcnum;    //边数
	GraphKind kind;
}AdjGraph;

//定义邻接表类
class ALGraph
{
private:
	AdjGraph ag;
};

  

2.1.2创建无向图和查找

  CreateGraph函数:

  该函数首先使用输入参数n和m来初始化图的顶点数和边数。它通过循环读入每个顶点的数据，并初始化顶点数组表。每个顶点的数据值被初始化为输入的值，而第一条边的地址被初始化为NULL。 接着，它通过循环读入每条边的信息，并建立边集。对于每条边，它查找两个顶点的位置，然后创建一个新的ArcNode来存储这条边。如果图是无向的（kind == UDN），它还会创建另一个ArcNode来存储反向边。

  LocateVex函数:

  这个函数用于查找给定数据值在顶点数组表中的位置。 它遍历整个顶点数组表，如果找到匹配的数据值，就返回该位置的索引；否则，返回-1。

//创建无向图
void CreateGraph(int n, int m)
{
	ag.vexnum = n;  //ag有n个顶点
	ag.arcnum = m;  //ag有m个边

	ag.kind = UDN;
	int i, j, w, h, t;
	VElemType u, v;
	ArcNode* p;
	for (i = 0; i < n; i++)  //初始化顶点数组表
	{
		cin >> ag.vertices[i].data;
		ag.vertices[i].fistarc = NULL;
	}

	for (j = 0; j < m; j++) //建立边集
	{
		cin >> u >> v >> w;  //输入一条弧<u,v,w>
		h = LocateVex(u);
		t = LocateVex(v);
		p = new ArcNode;  //储存无向边
		p->adjvex = t;
		p->info = w;
		p->nextarc = ag.vertices[h].fistarc;
		if (ag.kind == UDN)  //储存无向边（v,u）
		{
			ag.vertices[h].fistarc = p;
			p = new ArcNode;
			p->adjvex = h;
			p->info = w;
			p->nextarc = ag.vertices[t].fistarc;
			ag.vertices[t].fistarc = p;
		}
	}
}

//查找顶点信息在数组中的下表
int LocateVex(VElemType u)
{
	for (int i = 0; i < ag.vexnum; i++)
	{
		if (u == ag.vertices[i].data)
		{
			return i;
		}
	}

	return -1;
}

  

2.1.3插入边

  InsertArcGraph：

  接受三个参数：顶点u、顶点v和边的权重info。代码实现了向图中插入新的边的功能。如果指定的两个顶点不存在，则会在顶点数组表中插入它们。 然后，创建两个新的ArcNode节点来代表双向边，并将它们插入到两个顶点的第一条边链表中。最后，更新图的状态信息（顶点数和边数）。

//插入边
void InsertArcGraph(VElemType u, VElemType v, int info)
{
	int h = LocateVex(u), t = LocateVex(v);
	ArcNode* p;
	if (h == -1)  //在顶点数组表中插入顶点u
	{
		ag.vertices[ag.vexnum].data = u;
		ag.vertices[ag.vexnum].fistarc = NULL;
		h = ag.vexnum;
		ag.vexnum++;
	}
	if (t == -1)  //在顶点数组表中插入顶点t
	{
		ag.vertices[ag.vexnum].data = v;
		ag.vertices[ag.vexnum].fistarc = NULL;
		t = ag.vexnum;
		ag.vexnum++;
	}
	p = new ArcNode;
	p->adjvex = t;
	p->info = info;
	p->nextarc = ag.vertices[h].fistarc;
	ag.vertices[h].fistarc = p;

	p = new ArcNode;
	p->adjvex = h;
	p->info = info;
	p->nextarc = ag.vertices[t].fistarc;
	ag.vertices[t].fistarc = p;
	ag.arcnum++;
}

  

2.1.4打印函数

  Print()

  这段代码是一个用于打印图的顶点和边信息的函数。 它遍历图的顶点数组表和邻接表，并打印每个顶点的索引、数据值和邻居信息。输出格式可以帮助理解图的结构和连接关系。

//打印函数
void Print()
{
	// 顶点
	for (size_t i = 0; i < ag.vexnum; ++i)
	{
		cout << "[" << i << "]" << "->" << ag.vertices[i].data << endl;
	}
	cout << endl;

	for (size_t i = 0; i < ag.vexnum; ++i)
	{
		cout << ag.vertices[i].data << "[" << i << "]->";
		ArcNode* cur = ag.vertices[i].fistarc;
		while (cur)
		{
			cout << "[" << cur->adjvex << ":" << cur->info << "]->";
			cur = cur->nextarc;
		}
		cout << "NULL" << endl;
	}

	cout << endl;
}

  

2.2图的深度优先搜索（DFS）

  深度优先搜索（DFS）是一种用于遍历或搜索树或图的算法。这个算法会尽可能深地搜索图的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。

  实现图的深度优先搜索（DFS）的算法。我们使用递归即可，同时要使用数组vis来追踪哪些节点已经被访问过。

  在DFS函数中，我们应该使用节点的索引进行访问和标记，如果遇到了没有标记的点，就进行DFS操作，直到遍历完我们所有的图即可。
在这里插入图片描述

//深度优先搜索
int vis[MAXVex];
void DFS(VElemType v)
{
	ArcNode* p;
	int h = LocateVex(v);
	cout << v;
	vis[h] = 1;
	for (p = ag.vertices[h].fistarc; p; p = p->nextarc)
	{
		if (vis[p->adjvex] == 0)
		{
			DFS(ag.vertices[p->adjvex].data);
		}
	}
}
void DFSTraverse()
{
	int i;
	for (i = 0; i < ag.vexnum; i++)
	{
		vis[i] = 0;
	}
	for (i = 0; i < ag.vexnum; i++)
	{
		if (!vis[i])
		{
			DFS(ag.vertices[i].data);
		}
	}
	cout << endl;
}

  

2.3图的广度优先搜索（BFS）

  广度优先搜索（BFS）是一种用于图的遍历或搜索的算法。这种算法会尽可能广地搜索图的节点，从一个起始节点开始，探索邻近节点，然后再探索下一层级的节点。

  图的广度优先搜索（BFS）算法，我们可以利用队列来实现，它是在图中查找从给定源节点到所有其他节点的路径的算法。在的代码中，我们需要定义了一个数组visi来跟踪已经访问过的节点，然后使用队列lq来存储待访问的节点。

  在BFSTraverse函数中，我们先初始化visi数组，然后遍历所有的节点。如果一个节点尚未被访问，你就调用BFS函数进行访问。使用传递进来的节点数据来查找其在图中的索引，然后不断重复操作，知道队列中的数据为0。
在这里插入图片描述

//广度优先搜索
int visi[MAXVex];
void BFS(VElemType v)
{
	int h = LocateVex(v);
	ArcNode* p;
	queue<VElemType> lq;
	lq.push(h);
	visi[h] = 1;
	while (!lq.empty())
	{
		h=lq.front();
		lq.pop();
		cout << ag.vertices[h].data;
		for (p = ag.vertices[h].fistarc; p; p = p->nextarc)
		{
			if (!visi[p->adjvex])
			{
				lq.push(p->adjvex);
				visi[p->adjvex] = 1;
			}
		}
	}
}
void BFSTraverse()
{
	int i;
	for (i = 0; i < ag.vexnum; i++)
	{
		visi[i] = 0;
	}
	for (i = 0; i < ag.vexnum; i++)
	{
		if (!visi[i])
		{
			BFS(ag.vertices[i].data);
		}
	}
	cout << endl;
}

            

3.全部源码

测试：

在这里插入图片描述
在这里插入图片描述

  

Graph.h

#pragma once

#include<queue>

namespace link_table
{
#define MAXVex 20 //最大的顶点数	
#define VElemType int

typedef enum {
	DG,    //有向图
	UDG,   //无向图
	DN,    //有向网
	UDN    //无向网
}GraphKind;

//定义边
typedef struct 
{
	VElemType tail;
	VElemType head;
	int cost;
}Edge;

//定义边节点
typedef struct ArcNode 
{
	int adjvex;	 //终点在数组表中的下表
	int info;	 //权值
	ArcNode* nextarc; //下一个边的地址
}ArcNode;

//定义表头节点
typedef struct
{
	VElemType data;	 
	ArcNode* fistarc; //储存第一条边的结点地址
}VNode;

//定义邻接表
typedef struct
{
	VNode vertices[MAXVex]; //储存MAXVex个VNode的数组表
	int vexnum;    //顶点数
	int arcnum;    //边数
	GraphKind kind;
}AdjGraph;

//定义邻接表类
class ALGraph
{
public:
	//创建无向图
	void CreateGraph(int n, int m)
	{
		ag.vexnum = n;  //ag有n个顶点
		ag.arcnum = m;  //ag有m个边

		ag.kind = UDN;
		int i, j, w, h, t;
		VElemType u, v;
		ArcNode* p;
		for (i = 0; i < n; i++)  //初始化顶点数组表
		{
			cin >> ag.vertices[i].data;
			ag.vertices[i].fistarc = NULL;
		}

		for (j = 0; j < m; j++) //建立边集
		{
			cin >> u >> v >> w;  //输入一条弧<u,v,w>
			h = LocateVex(u);
			t = LocateVex(v);
			p = new ArcNode;  //储存无向边
			p->adjvex = t;
			p->info = w;
			p->nextarc = ag.vertices[h].fistarc;
			if (ag.kind == UDN)  //储存无向边（v,u）
			{
				ag.vertices[h].fistarc = p;
				p = new ArcNode;
				p->adjvex = h;
				p->info = w;
				p->nextarc = ag.vertices[t].fistarc;
				ag.vertices[t].fistarc = p;
			}
		}
	}

	//查找顶点信息在数组中的下表
	int LocateVex(VElemType u)
	{
		for (int i = 0; i < ag.vexnum; i++)
		{
			if (u == ag.vertices[i].data)
			{
				return i;
			}
		}

		return -1;
	}

	//计算顶点的度数
	int Degree(VElemType u)
	{
		int h = LocateVex(u);
		int count = 0;
		ArcNode* p = ag.vertices[h].fistarc;
		while (p)
		{
			count++;
			p = p->nextarc;
		}

		return count;
	}

	//插入边
	void InsertArcGraph(VElemType u, VElemType v, int info)
	{
		int h = LocateVex(u), t = LocateVex(v);
		ArcNode* p;
		if (h == -1)  //在顶点数组表中插入顶点u
		{
			ag.vertices[ag.vexnum].data = u;
			ag.vertices[ag.vexnum].fistarc = NULL;
			h = ag.vexnum;
			ag.vexnum++;
		}
		if (t == -1)  //在顶点数组表中插入顶点t
		{
			ag.vertices[ag.vexnum].data = v;
			ag.vertices[ag.vexnum].fistarc = NULL;
			t = ag.vexnum;
			ag.vexnum++;
		}
		p = new ArcNode;
		p->adjvex = t;
		p->info = info;
		p->nextarc = ag.vertices[h].fistarc;
		ag.vertices[h].fistarc = p;

		p = new ArcNode;
		p->adjvex = h;
		p->info = info;
		p->nextarc = ag.vertices[t].fistarc;
		ag.vertices[t].fistarc = p;
		ag.arcnum++;
	}

	//深度优先搜索
	int vis[MAXVex];
	void DFS(VElemType v)
	{
		ArcNode* p;
		int h = LocateVex(v);
		cout << v;
		vis[h] = 1;
		for (p = ag.vertices[h].fistarc; p; p = p->nextarc)
		{
			if (vis[p->adjvex] == 0)
			{
				DFS(ag.vertices[p->adjvex].data);
			}
		}
	}
	void DFSTraverse()
	{
		int i;
		for (i = 0; i < ag.vexnum; i++)
		{
			vis[i] = 0;
		}
		for (i = 0; i < ag.vexnum; i++)
		{
			if (!vis[i])
			{
				DFS(ag.vertices[i].data);
			}
		}
		cout << endl;
	}

	//广度优先搜索
	int visi[MAXVex];
	void BFS(VElemType v)
	{
		int h = LocateVex(v);
		ArcNode* p;
		queue<VElemType> lq;
		lq.push(h);
		visi[h] = 1;
		while (!lq.empty())
		{
			h=lq.front();
			lq.pop();
			cout << ag.vertices[h].data;
			for (p = ag.vertices[h].fistarc; p; p = p->nextarc)
			{
				if (!visi[p->adjvex])
				{
					lq.push(p->adjvex);
					visi[p->adjvex] = 1;
				}
			}
		}
	}
	void BFSTraverse()
	{
		int i;
		for (i = 0; i < ag.vexnum; i++)
		{
			visi[i] = 0;
		}
		for (i = 0; i < ag.vexnum; i++)
		{
			if (!visi[i])
			{
				BFS(ag.vertices[i].data);
			}
		}
		cout << endl;
	}

	//打印函数
	void Print()
	{
		// 顶点
		for (size_t i = 0; i < ag.vexnum; ++i)
		{
			cout << "[" << i << "]" << "->" << ag.vertices[i].data << endl;
		}
		cout << endl;

		for (size_t i = 0; i < ag.vexnum; ++i)
		{
			cout << ag.vertices[i].data << "[" << i << "]->";
			ArcNode* cur = ag.vertices[i].fistarc;
			while (cur)
			{
				cout << "[" << cur->adjvex << ":" << cur->info << "]->";
				cur = cur->nextarc;
			}
			cout << "NULL" << endl;
		}

		cout << endl;
	}

private:
	AdjGraph ag;
};

}

  

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

#include"Graph.h"

void TestGraph1()
{
	link_table::ALGraph ag;
	ag.CreateGraph(0, 0);
	ag.InsertArcGraph(0, 1, 7);
	ag.InsertArcGraph(0, 2, 3);
	ag.InsertArcGraph(0, 3, 4);
	ag.InsertArcGraph(3, 4, 6);
	ag.InsertArcGraph(1, 2, 5);
	ag.InsertArcGraph(1, 3, 2);
	ag.InsertArcGraph(1, 4, 1);
	ag.InsertArcGraph(2, 4, 7);

	cout << "该相邻表为:\n";
	ag.Print(); 
	cout << "深度优先搜索的结果为:";
	ag.DFSTraverse();
	cout << "广度优先搜索的结果为:";
	ag.BFSTraverse();

}

int main()
{
	TestGraph1();
	return 0;
}

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

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

相关文章

RT-DETR算法优化改进：可变形大核注意力（D-LKA Attention），超越自注意力，实现暴力涨点 | 2023.8月最新发表

RT-DETR算法优化改进：可变形大核注意力（D-LKA Attention），超越自注意力，实现暴力涨点 | 2023.8月最新发表

💡💡💡本文独家改进: 可变形大核注意力（D-LKA Attention），采用大卷积核来充分理解体积上下文的简化注意力机制，来灵活地扭曲采样网格，使模型能够适当地适应不同的数据模式 1）代替RepC3进行使用； 推荐指数：五星 RT-DETR魔术师专栏介绍： https://blog.csdn.n…
阅读更多...
Java图像编程之：Graphics2D

Java图像编程之：Graphics2D

一、介绍 1、Java图像编程的核心类 BufferedImage&#xff1a;用于表示图像的类&#xff0c;可以进行像素级的操作。Image&#xff1a;表示图像的抽象类&#xff0c;是所有图像类的基类。ImageIcon&#xff1a;用于显示图像的类&#xff0c;可以将图像嵌入到Swing组件中。Ima…
阅读更多...
麒麟信安登录央视，深度展现为中国信息安全铸“魂”之路

麒麟信安登录央视，深度展现为中国信息安全铸“魂”之路

麒麟信安登录央视&#xff0c;深度展现为中国信息安全铸“魂”之路 近日&#xff0c;麒麟信安登录央视频道&#xff0c;《麒麟信安——为中国信息安全铸“魂”》在CCTV-4中文国际频道、CCTV-7国防军事频道、CCTV-10 科教频道、CCTV-12社会与法频道、CCTV-17农业农村频道&#x…
阅读更多...
RT-DETR算法优化改进：新颖的多尺度卷积注意力（MSCA），即插即用，助力小目标检测 | NeurIPS2022

RT-DETR算法优化改进：新颖的多尺度卷积注意力（MSCA），即插即用，助力小目标检测 | NeurIPS2022

💡💡💡本文独家改进: 多尺度卷积注意力（MSCA），有效地提取上下文信息，新颖度高，创新十足。 1）代替RepC3进行使用； 2）MSCAAttention直接作为注意力进行使用； 推荐指数：五星 RT-DETR魔术师专栏介绍： https://blog.csdn.net/m0_63774211/category_12497375.ht…
阅读更多...
【Docker】深入理解Docker：一种革新性的容器技术

【Docker】深入理解Docker：一种革新性的容器技术

前言 Docker 是一个开源的应用容器引擎&#xff0c;让开发者可以打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何流行的Linux或Windows操作系统的机器上,也可以实现虚拟化,容器是完全使用沙箱机制,相互之间不会有任何接口。 &#x1f4d5;作者简介&#xff1a;热…
阅读更多...
Python实现WOA智能鲸鱼优化算法优化BP神经网络分类模型(BP神经网络分类算法)项目实战

Python实现WOA智能鲸鱼优化算法优化BP神经网络分类模型(BP神经网络分类算法)项目实战

说明&#xff1a;这是一个机器学习实战项目&#xff08;附带数据代码文档视频讲解&#xff09;&#xff0c;如需数据代码文档视频讲解可以直接到文章最后获取。 1.项目背景 鲸鱼优化算法 (whale optimization algorithm,WOA)是 2016 年由澳大利亚格里菲斯大学的Mirjalili 等提…
阅读更多...
Allegro层叠中的Etch Factor-铜皮的腐蚀因子如何计算

Allegro层叠中的Etch Factor-铜皮的腐蚀因子如何计算

Allegro层叠中的Etch Factor-铜皮的腐蚀因子如何计算 在用Allegro进行PCB设计的时候，Cross-section中需要填入对应的信息，一般填入每层的厚度即可，如下图 当PCB需要进行仿真分析的时候，Etch-Factor这个值是必须要填写的，如下图 目前看到的都是90这个值，这是一个理论值。 …
阅读更多...
Transformer详解一：transformer的由来和先导知识

Transformer详解一：transformer的由来和先导知识

目录 参考资料前言一、预训练二、神经网络语言模型&#xff08;NNLM&#xff09;&#xff1a;预测下一个词one-hot编码的缺陷词向量&#xff08;word embedding&#xff09; 三、Word2Vec模型&#xff1a;得到词向量CBOWSkip-gramWord2Vec和NNLM的区别Word2Vec的缺陷 四、ELMO模…
阅读更多...
个推「数据驱动运营增长」城市巡回沙龙·上海专场：网易云音乐如何用数据驱动活跃和留存？

个推「数据驱动运营增长」城市巡回沙龙·上海专场：网易云音乐如何用数据驱动活跃和留存？

近日&#xff0c;以“数据增能&#xff0c;高效提升用户运营价值”为主题的个推「数据驱动运营增长」城市巡回沙龙上海专场圆满举行。活动现场&#xff0c;网易云音乐平台运营总监曹鲁豫以“数据驱动活跃和留存”为主题&#xff0c;深度分享了网易云音乐的数智化运营实践。 ▲ …
阅读更多...
leetcode刷题日记:118.Pascal‘s Triangle(杨辉三角)

leetcode刷题日记:118.Pascal‘s Triangle(杨辉三角)

118.Pascal’s Triangle(杨辉三角&#xff09; 题目给我们一个整数numRows表示杨辉三角形的行数&#xff0c;返回杨辉三角形的前numRows行&#xff0c;下面给出一个杨辉三角形看看它有哪些规律&#xff1b; 可以看出杨辉三角形的每一行的最左侧和最右侧的值都为1. 其余的第…
阅读更多...
在个人简历中为什么要写个人优势？

在个人简历中为什么要写个人优势？

问题描述&#xff1a; 在个人简历中为什么要写个人优势&#xff1f; 解决方案&#xff1a; 在个人简历中写个人优势的目的是突出你作为求职者的独特优势和价值&#xff0c;一段精简且亮眼的介绍能够快速抓住HR的眼球&#xff0c;判断你与岗位的契合度&#xff0c;进而对你产生…
阅读更多...
Amazon Bedrock | 大语言模型CLAUDE 2体验

Amazon Bedrock | 大语言模型CLAUDE 2体验

这场生成式AI与大语言模型的饥饿游戏&#xff0c;亚马逊云科技也参与了进来。2023年&#xff0c;亚马逊云科技正式发布了 Amazon Bedrock&#xff0c;是客户使用基础模型构建和扩展生成式AI应用程序的最简单方法&#xff0c;为所有开发者降低使用门槛。在 Bedrock 上&#xff0…
阅读更多...
RT-DETR算法优化改进：Backbone改进 | HGBlock完美结合PPHGNetV2 RepConv

RT-DETR算法优化改进：Backbone改进 | HGBlock完美结合PPHGNetV2 RepConv

💡💡💡本文独家改进： PPHGNetV2助力RT-DETRHGBlock与PPHGNetV2 RepConv完美结合 推荐指数：五星 HGBlock_PPHGNetV2 | 亲测在多个数据集能够实现涨点 RT-DETR魔术师专栏介绍： https://blog.csdn.net/m0_63774211/category_12497375.html ✨✨✨魔改创新RT-DETR…
阅读更多...
项目生命周期分享

项目生命周期分享

第一阶段&#xff1a; 项目启动&#xff0c;2天时间即可&#xff0c;需要输出项目进度计划 1.项目组成立1天&#xff0c;用来建立项目组&#xff0c;确定工作分工和工作方法&#xff0c;指定项目总体计划&#xff08;包括前期交流&#xff0c;需求收集&#xff0c;项目立项等…
阅读更多...
使用Inis搭配内网穿透实现Ubuntu上快速搭建博客网站远程访问

使用Inis搭配内网穿透实现Ubuntu上快速搭建博客网站远程访问

文章目录 前言1. Inis博客网站搭建1.1. Inis博客网站下载和安装1.2 Inis博客网站测试1.3 cpolar的安装和注册 2. 本地网页发布2.1 Cpolar临时数据隧道2.2 Cpolar稳定隧道&#xff08;云端设置&#xff09;2.3.Cpolar稳定隧道&#xff08;本地设置&#xff09; 3. 公网访问测试总…
阅读更多...
定了！2023年汉字小达人市级比赛11月30日16点举办，几个须关注点

定了！2023年汉字小达人市级比赛11月30日16点举办，几个须关注点

好消息&#xff01; 今天上午&#xff0c;汉字小达人主办方在中文自修官网发布了《“中文自修杯”第十届上海市小学生“美丽汉字小达人”市级活动通知》&#xff0c;算是把今年的的汉字小达人市级比赛的具体安排正式敲定了&#xff0c;前期已经进入市赛的小朋友可以更有节奏地…
阅读更多...
Juniper SRX PPPoE配置

Juniper SRX PPPoE配置

直接上配置脚本 6号口接运营商进行拨号 ---------- set interfaces ge-0/0/6 unit 0 encapsulation ppp-over-ether set interfaces ge-0/0/6 description "Connect_to_Modem" set interfaces pp0 unit 0 pppoe-options underlying-interface ge-0/0/6.0 set inte…
阅读更多...
【哈夫曼树的构造和查找最小的的权值结点代码，哈夫曼编码的算法实现】

【哈夫曼树的构造和查找最小的的权值结点代码，哈夫曼编码的算法实现】

文章目录 哈夫曼树的构造和查找最小的的权值结点代码哈夫曼编码思想哈夫曼编码的算法实现 哈夫曼树的构造和查找最小的的权值结点代码 #include<iostream> using namespace std;typedef struct {int parent, lch, rch;//双亲结点和孩子结点的下标int weight;//权值 }htN…
阅读更多...
SpringBoot3基础特性

SpringBoot3基础特性

SpringBoot3基础特性 SpringApplication 自定义banner 类路径添加banner.txt或设置spring.banner.location就可以定制banner推荐网站:Spring Boot banner在线生成工具&#xff0c;制作下载英文banner.txt,修改替换banner.txt文字实现自定义。 提示&#xff1a; 可以通过修改配…
阅读更多...
ChineseChess.2023.11.13.01

ChineseChess.2023.11.13.01

中国象棋残局模拟器ChineseChess.2023.11.13.01
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023