【数据结构】迷宫问题DFS非递归（c语言实现）

news2024/11/28 7:30:16

本来之前写过一个推箱子，就想着写个迷宫游戏，因为想着推箱子游戏里面也有墙，也有玩家的移动，比推箱子简单的是还不用判断前面是否有箱子的情况，但是自己写的迷宫游戏如果自己随机生成的迷宫地图的话，不一定会有通路，他要学一个什么随机迷宫的生成，刚看完懒猫老师的那个迷宫问题使用的是非递归DFS寻找迷宫是否有通路，用的是非递归DFS实现，然后随机迷宫生成用的是DFS递归写的，我真的要成两半了，今天分享给大家的是DFS算法找迷宫是否有出路，这个好像有的会作为数据结构的大作业还是啥的，用c语言实现，参考b站懒猫老师的课迷宫问题

1.问题展示

在这里插入图片描述

2.栈的所有有用的函数

因为要用栈实现，所以我们必须将有关栈的函数全部写出来，我们已经之前写过栈的初始化，等等，栈的实现，我们将他拷贝过来，或者你们直接去看我那一篇。

//栈的实现
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

typedef struct Stack//定义一个栈的结构体变量	
{
	int * a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;
void StackInit(Stack* ps)
{
	assert(ps);//断言，防止为空指针
	ps->a = NULL;//所指向的地址为空
	ps->capacity = ps->top = 0;//容量和栈中元素个数均为0
}
void StackPush(Stack* ps, int data)
{
	assert(ps);
	if (ps->capacity == ps->top)//如果栈中的元素个数等于栈的容量时考虑扩容，
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果刚开始时都等于0，就先给4个空间大小，后面如果满的话，容量扩大1倍
		 int* newnode = (int*)realloc(ps->a,sizeof(int)* newcapcity);//申请空间，将申请好的空间首地址传给newnode指针
		 assert(newnode);//断言，防止malloc失败
		 ps->a = newnode;//将newnode保存的申请空间的首地址传给ps->a,让ps->a指向创建好的空间
		ps->capacity = newcapcity;//容量大小更新为新容量大小



	}
	ps->a[ps->top] = data;//像存数组一样存数据
	ps->top++;//指向下一个
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top ==0;//ps->top为栈中元素个数.==0栈中无元素，无元素要返回1， 无元素ps->t0p==0，这个表达式结果是1，返回1;





}
// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));//防止栈内无元素，继续出栈
	ps->top--;
}
// 获取栈顶元素
int StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];//ps->top为栈中元素个数，由于数组下标是从0开始，所以栈顶元素下标为ps->top-1;

}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;

}
// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);//free掉动态申请的内存
	ps->a = NULL;//防止野指针
	ps->capacity = ps->top = 0;//容量和栈中元素个数置为0



}

但是不能直接用，所以我们必须加以修改，我们会将从入口到出口正确的路径坐标，以及每个坐标对应走向下一个坐标的方向保存在栈里面，由我之前实现的栈中一个元素变为三个元素，栈的实现做出以下改变，int * a，a指针不在指向一个int ，将inta改为proa;pro为结构体类型存放三个元素

typedef struct pro
{
	int x;
	int y;
	int di;




}pro;
typedef struct Stack
{
	pro* a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;

由于一次压进三个数据，我们要修改入栈函数

void StackPush(Stack* ps, int data1, int data2, int data3)//入栈
{
	assert(ps);
	
	if (ps->capacity == ps->top)
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		pro* tmp = (pro*)realloc(ps->a, sizeof(pro) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapcity;



		}






	}
	ps->a[ps->top].x = data1;
	ps->a[ps->top].y = data2;
	ps->a[ps->top].di = data3;
	ps->top++;







}

由于每层由之前一个元素变为三个元素，所以要修改获取栈顶元素函数，返回栈顶地址，然后通过地址来访问三个元素中的每一个

// 获取栈顶元素
pro* StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a+ps->top-1;

}

3.修改后的栈的实现

typedef struct pro
{
	int x;
	int y;
	int di;




}pro;
typedef struct Stack
{
	pro* a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;
void StackInit(Stack* ps)//初始化栈
{
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(Stack* ps, int data1, int data2, int data3)//入栈
{
	assert(ps);
	//assert(ps->a);
	if (ps->capacity == ps->top)
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		pro* tmp = (pro*)realloc(ps->a, sizeof(pro) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapcity;



		}






	}
	ps->a[ps->top].x = data1;
	ps->a[ps->top].y = data2;
	ps->a[ps->top].di = data3;
	ps->top++;







}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;



}
// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;

}
// 获取栈顶元素
pro* StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a+ps->top-1;

}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;





}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;

}

4. 定义二维数组作为迷宫的地图

我们这里将1看做墙，0看做空地可以走的地方，然后迷宫入口坐标为（1,1），我们定义二维数组为M*N的

#define N 10
#define M 10

迷宫出口坐标为（M-2,N-2）;
定义全局变量，方便使用

int map[M][N] = {
	{1,1,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,0,0,0,0,0,0,0,1},
	{1,1,1,1,1,1,1,1,1,1},
};

在这里插入图片描述
黑框标注的分别为入口和出口.
在定义一个结构体，表示要走的方向

typedef struct direct 
{
	int conx;
	int cony;

}direct;

在主函数里面定义一个direct类型的数组，数组大小为四，存放上下左右走，坐标的变化，并且将他们赋值

   direct des[4];
	des[0].conx = 1;//向右走
	des[0].cony = 0;
	des[1].conx = -1;//向左走
	des[1].cony = 0;
	des[2].conx = 0;//向下走
	des[2].cony = 1;
	des[3].conx = 0;//向上走
	des[3].cony = -1;

在这里插入图片描述
向哪走就给对应坐标+上什么的，比如说我向右走，x+des[0].conx ,y+des[0].cony;

5.定义一个栈，将其初始化，当用完时候将其销毁

int main()
{
	
	direct des[4];
	des[0].conx = 1;//向右走
	des[0].cony = 0;
	des[1].conx = -1;//向左走
	des[1].cony = 0;
	des[2].conx = 0;//向下走
	des[2].cony = 1;
	des[3].conx = 0;//向上走
	des[3].cony = -1;
	Stack st;
	
	StackInit(&st);
	
  
		StackDestroy(&st);
		StackDestroy(&scpy);
	return 0;

}

6. DFS算法寻找迷宫是否有通路

bool  findpath(int map[][N], direct des[], Stack* ps)
{
	int line, col;//表示当前位置能走的下一个位置的坐标
	int x, y, di;//表示当前位置的坐标，以及当前位置准备向下一个方向走的方向
	int mapcon[M][N] = { 0 };//为了不修改原有的地图，重新创建一个二维数组
	for (int i = 0; i < M; i++)//遍历地图，将原地图的二维数组的值拷贝到mapcon中
	{
		for (int j = 0; j < N; j++)
		{  
			mapcon[i][j] = map[i][j];
			
		


		}
		
	}
	

	mapcon[1][1] = -1;//走过的地方用-1标记
	pro tmp;//保存当前位置的坐标，以及方向
	tmp.x = 1;
	tmp.y = 1;
	tmp.di = -1;//刚开始在（1,1），将tmp.x，tmp.y赋值为1，刚开始还没有方向tmp.di = -1；
	StackPush(ps, tmp.x, tmp.y, tmp.di);//将当前位置信息压入st栈中

	while (!StackEmpty(ps))//栈中不为空，开始循环
	{
		tmp.x = StackTop(ps)->x;
		tmp.y = StackTop(ps)->y;
		tmp.di = StackTop(ps)->di;//获取栈顶元素到tmp中去，以便于回退
		StackPop(ps);//出栈操作
		x = tmp.x;//当前坐标改为回退之后的坐标
		y = tmp.y;//当前坐标改为回退之后的坐标
		di = tmp.di + 1;//开始di=0,方向向右
		while (di < 4)//遍历当前位置的四个方向
		{
			line = x + des[di].conx;//记录下一个位置的坐标
			col = y + des[di].cony;//记录下一个位置的坐标
			if (mapcon[line][col] == 0)//如果下一个坐标时0，为空地的话，就可以前进
			{
				tmp.x = x;//保存当前位置坐标，以便于回退
				tmp.y = y;//保存当前位置坐标，以便于回退
				tmp.di = di;//保存当前位置坐标，以便于回退
				StackPush(ps, tmp.x, tmp.y, tmp.di);//当前位置目前确定是通往出口路上的一个坐标，先入栈
				x = line;//当前位置更新为下一个位置的坐标
				y = col;//当前位置更新为下一个位置的坐标
				mapcon[line][col] = -1;//留下足迹，标记为-1；
				if (x == M - 2 && y == N - 2)//是否到出口
				
					

					return true;//有通路，跳出
				
				
				else di = 0;//没到的话，将方向更新为向右
			}
			else di++;//如果当前位置的方向不是空地的话，就换另一个方向判断


		}



	}

	return false;//循环结束，无通路

}

7. 逆序打印坐标

如果有通路的话， findpath（）函数返回1，由于栈是先入后出，所以栈顶元素是出口的坐标，怎么逆序打印从入口到出口的坐标呢？我们可以在创建一个栈，使用栈判空函数循环将st中的元素入栈到另一个栈中，就做到了在原先栈底元素，跑到了新栈的栈顶，实现了逆序打印
在这里插入图片描述

	Stack st;
	Stack scpy;//定义一个栈用于倒翻数据
	StackInit(&st);
	StackInit(&scpy);//新栈初始话
    bool ret = findpath(map, des, &st);//返回1，地图有通路
		if (ret == 1)
		{
			printf("该地图有通路\n");
			while (!StackEmpty(&st))//原栈不为空的话
			{
				int num1=StackTop(&st)->x;
				int num2 = StackTop(&st)->y;
				int num3= StackTop(&st)->di;//获取旧栈栈顶元素
				/*printf("%d-%d ",num1,num2);*/
				StackPop(&st);//栈顶元素出st栈
				StackPush(&scpy, num1, num2, num3);//栈顶元素入新栈scpy


			}
			
			
			while (!StackEmpty(&scpy))//新栈scpy不为空，
			{
				int num1 = StackTop(&scpy)->x;
				int num2 = StackTop(&scpy)->y;
				int num3 = StackTop(&scpy)->di;//获取栈顶元素
				printf("(%d,%d)\n", num1, num2);//打印栈顶元素
				StackPop(&scpy);//新栈栈顶元素出栈
			

			}
			
		}
		else
		{

			printf("该地图无通路\n");
		}
		StackDestroy(&st);//销毁旧栈
		StackDestroy(&scpy);//销毁新栈

只打印坐标，不要求方向，我就在栈中没画方向.

8.整体代码

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>


#include <stdbool.h>
#define N 10
#define M 10
int map[M][N] = {
	{1,1,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,1,1,1,1,1,1,1,1},
	{1,0,0,0,0,0,0,0,0,1},
	{1,1,1,1,1,1,1,1,1,1},
};
typedef struct pro
{
	int x;
	int y;
	int di;




}pro;
typedef struct direct 
{
	int conx;
	int cony;

}direct;






typedef struct Stack
{
	pro* a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;
void StackInit(Stack* ps)//初始化栈
{
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void StackPush(Stack* ps, int data1, int data2, int data3)//入栈
{
	assert(ps);
	//assert(ps->a);
	if (ps->capacity == ps->top)
	{
		int newcapcity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		pro* tmp = (pro*)realloc(ps->a, sizeof(pro) * newcapcity);
		if (tmp == NULL)
		{
			perror("realloc fail");
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapcity;



		}






	}
	ps->a[ps->top].x = data1;
	ps->a[ps->top].y = data2;
	ps->a[ps->top].di = data3;
	ps->top++;







}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;



}
// 出栈
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;

}
// 获取栈顶元素
pro* StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a+ps->top-1;

}
// 获取栈中有效元素个数
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;





}

// 销毁栈
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;

}
enum  Mine
{
	SPACE,  //空地
	WALL,//墙
	DEST,  //目的地
	PLAYER//玩家





};
bool  findpath(int map[][N], direct des[], Stack* ps)
{
	int line, col;
	int x, y, di;
	int mapcon[M][N] = { 0 };
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
		{  
			mapcon[i][j] = map[i][j];
			
		


		}
		
	}
	mapcon[M - 2][N - 2] = 0;

	mapcon[1][1] = -1;
	pro tmp;
	tmp.x = 1;
	tmp.y = 1;
	tmp.di = -1;
	StackPush(ps, tmp.x, tmp.y, tmp.di);

	while (!StackEmpty(ps))
	{
		tmp.x = StackTop(ps)->x;
		tmp.y = StackTop(ps)->y;
		tmp.di = StackTop(ps)->di;
		StackPop(ps);
		x = tmp.x;
		y = tmp.y;
		di = tmp.di + 1;
		while (di < 4)
		{
			line = x + des[di].conx;
			col = y + des[di].cony;
			if (mapcon[line][col] == 0)
			{
				tmp.x = x;
				tmp.y = y;
				tmp.di = di;
				StackPush(ps, tmp.x, tmp.y, tmp.di);
				x = line;
				y = col;
				mapcon[line][col] = -1;
				if (x == M - 2 && y == N - 2)
				
					

					return true;
				
				
				else di = 0;
			}
			else di++;


		}



	}

	return false;

}





int main()
{
	srand((unsigned int)time(NULL));
	direct des[4];
	des[0].conx = 1;//向右走
	des[0].cony = 0;
	des[1].conx = -1;//向左走
	des[1].cony = 0;
	des[2].conx = 0;//向下走
	des[2].cony = 1;
	des[3].conx = 0;//向上走
	des[3].cony = -1;
	Stack st;
	Stack scpy;
	StackInit(&st);
	StackInit(&scpy);
    bool ret = findpath(map, des, &st);
		if (ret == 1)
		{
			printf("该地图有通路\n");
			while (!StackEmpty(&st))
			{
				int num1=StackTop(&st)->x;
				int num2 = StackTop(&st)->y;
				int num3= StackTop(&st)->di;
				/*printf("%d-%d ",num1,num2);*/
				StackPop(&st);
				StackPush(&scpy, num1, num2, num3);


			}
			
			
			while (!StackEmpty(&scpy))
			{
				int num1 = StackTop(&scpy)->x;
				int num2 = StackTop(&scpy)->y;
				int num3 = StackTop(&scpy)->di;
				printf("(%d,%d)\n", num1, num2);
				StackPop(&scpy);
			

			}
			
		}
		else
		{

			printf("该地图无通路\n");
		}
		StackDestroy(&st);
		StackDestroy(&scpy);
	return 0;

}

9.编译运行

在这里插入图片描述

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

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

相关文章

Altium Designer培训 | 3 - PCB库创建篇

Altium Designer培训 | 3 - PCB库创建篇

参考文章 http://t.csdnimg.cn/T6ykf PCB封装的元素 PCB焊盘&#xff0c;焊接器件用的。管脚序号&#xff0c;和原理图管脚一一对应。丝印&#xff0c;是实物本体的大小范围。1脚标识&#xff0c;定位器件的正反方向。阻焊&#xff0c;防绿油覆盖的&#xff0c;把铜露出来&…
阅读更多...
使用Windows系统自带的安全加密解密文件操作步骤详解

使用Windows系统自带的安全加密解密文件操作步骤详解

原以为安全加密的方法是加密压缩包&#xff0c;有的需要用软件加密文件&#xff0c;可每次想往里面修改或存放文件都要先解密&#xff0c;不用时&#xff0c;还得去加密&#xff0c;操作步骤那么多&#xff0c;那多不方便呀&#xff0c;这里讲讲用系统自带的BitLocker加密工具怎…
阅读更多...
基于SSM的固定资产管理系统的设计与实现

基于SSM的固定资产管理系统的设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;采用JSP技术开发 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#x…
阅读更多...
Linux命令基本用法

Linux命令基本用法

1.用户相关命令 1.账号管理 命令作用useradd添加用户passwd设置密码usermod修改用户userdel删除用户su切换用户 例&#xff1a; [rootlocalhost ~]# useradd aaa [rootlocalhost ~]# su aaa [aaalocalhost root]$ su root 密码&#xff1a; [rootlocalhost ~]# passwd aaa …
阅读更多...
DynamicIPAccess.java

DynamicIPAccess.java

package webspider_20230929_paypal;import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL;/*** 动态IP访问** author ZengWenFeng* date 2023.10.08* email 117791303qq.com* mobile 13805029595*/ pub…
阅读更多...
CDN,DNS,ADN,SCDN,DCDN,ECDN,PCDN,融合CDN的介绍

CDN,DNS,ADN,SCDN,DCDN,ECDN,PCDN,融合CDN的介绍

一、CDN是什么&#xff1f; CDN的全称是Content Delivery Network&#xff0c;即内容分发网络。其基本思路是尽可能避开互联网上有可能影响数据传输速度和稳定性的瓶颈和环节&#xff0c;使内容传输得更快、更稳定。通过在网络各处放置节点服务器所构成的在现有的互联网基础之…
阅读更多...
【List-Watch】

【List-Watch】

List-Watch 一、定义二、工作机制三、调度过程 一、定义 Kubernetes 是通过 List-Watch 的机制进行每个组件的协作&#xff0c;保持数据同步的&#xff0c;每个组件之间的设计实现了解耦。 用户是通过 kubectl 根据配置文件&#xff0c;向 APIServer 发送命令&#xff0c;在 …
阅读更多...
Acwing.788 逆序对的数量

Acwing.788 逆序对的数量

题目 给定一个长度为n的整数数列&#xff0c;请你计算数列中的逆序对的数量。 逆序对的定义如下:对于数列的第i个和第j个元素&#xff0c;如果满i<j且ali]>ali]&#xff0c;则其为一个逆序对;否则不是. 输入格式 第一行包含整数n&#xff0c;表示数列的长度。 第二行包…
阅读更多...
Redis学习（九）SpringBoot实现（Pub/Sub）发布订阅

Redis学习（九）SpringBoot实现（Pub/Sub）发布订阅

目录 一、背景二、Redis的发布订阅2.1 订阅单个频道常用命令 2.2 按规则&#xff08;Pattern&#xff09;订阅频道2.3 不推荐使用的原因 三、SpringBoot实现发布订阅3.1 RedisUtil.java 发布类1&#xff09;MessageDTO.java 实体类2&#xff09;发布测试 3.2 订阅实现方式一&am…
阅读更多...
day10.8ubentu流水灯

day10.8ubentu流水灯

流水灯 .text .global _start _start: 1.设置GPIOE寄存器的时钟使能 RCC_MP_AHB4ENSETR[4]->1 0x50000a28LDR R0,0X50000A28LDR R1,[R0] 从r0为起始地址的4字节数据取出放在R1ORR R1,R1,#(0x1<<4) 第4位设置为1STR R1,[R0] 写回2.设置PE10管脚为输出模式 G…
阅读更多...
C#LINQ

C#LINQ

LINQ&#xff08;Language Integrated Query )语言集成查询&#xff0c;是一组用于C#和VB语言的拓展&#xff0c;它允许VB或者C#代码以操作内存数据的方式&#xff0c;查询数据库。 LINQ使用的优点&#xff1a; 无需复杂学习过程即可上手。编写更少代码即可创建完整应用。更快…
阅读更多...
okhttp4.11源码分析

okhttp4.11源码分析

目录 一&#xff0c;OKHTTP时序图 二&#xff0c;OKHTTP类图 三&#xff0c;OKHTTP流程图 一&#xff0c;OKHTTP时序图 上图是整个okhttp一次完整的请求过程&#xff0c;时序图里面有些部分为了方便采用了简单的描述&#xff0c;描述了主要的流程&#xff0c;细节的话&#…
阅读更多...
数据结构之堆，栈的实现

数据结构之堆，栈的实现

首先我们分析由于只需要尾进尾出&#xff0c;用数组模拟更简单。 实现的功能如上图。 top可以表示栈中元素个数。 capacity表示栈的容量。 首先是堆的初始化 再就是栈的插入和删除 然后实现显示栈顶元素 大小和检测是否为空的实现 销毁栈的实现&#xff08;防止内存泄露&…
阅读更多...
【无标题】Delayed延迟队列不工作

【无标题】Delayed延迟队列不工作

背景 项目中使用java 自带的延迟队列Delayed&#xff0c;只有添加进队列的消息&#xff0c;并没有被消费到 版本 jdk1.8 问题原因 上一个消费队列出现异常并且没有捕获&#xff0c;下一个队列就没有进行消费 复现代码 没有抛异常的情况下 package com.ccb.core.config.…
阅读更多...
10.8c++作业

10.8c++作业

#include <iostream>using namespace std; class Rect {int width; //宽int height; //高 public://初始化函数void init(int w,int h){widthw;heighth;}//更改宽度void set_w(int w){widthw;}//更改高度void set_h(int h){heighth;}//输出矩形周长和面积void show(){co…
阅读更多...
2023年铷铁硼行业分析：低端供应过剩，高性能材料供应不足[图]

2023年铷铁硼行业分析：低端供应过剩，高性能材料供应不足[图]

铷铁硼材料是一种Fe基磁性材料&#xff0c;主要由钕铁硼按一定比例组成的四方晶体结构&#xff0c;其中Fe元素约占总质量的三分之二&#xff0c;Nd元素约占总量的三分之一&#xff0c;而B等含量最少&#xff0c;约占1%。铷铁硼是现今磁性最强的永久磁铁&#xff0c;也是最常使用…
阅读更多...
波奇学C++：用红黑树模拟实现map和set

波奇学C++：用红黑树模拟实现map和set

用同一个树的类模板封装map(key/value)和set(key) 红黑树的Node template<class T> struct RBTreeNode {RBTreeNode<T>* _left;RBTreeNode<T>* _right;RBTreeNode<T>* _parent;T _data;Colour _col;RBTreeNode(const T& data):_left(nullptr),_r…
阅读更多...
python工具-内存采集展示

python工具-内存采集展示

1. 查看某个进程的内存占用 1. 查看某个进程的内存占用 1.1. 采集1.2. 分析 1.1. 采集 下边内存保存为 cat-memory.sh 脚本文件&#xff0c;赋予可执行权限执行 ./cat-memory.sh pid 会生成 pid.txt #!/bin/bashprocess$1 out$1.txt pid$1echo 时间 内存(KB) >> $ou…
阅读更多...
复旦大学EMBA：揭秘科创企业，领略未来战略！

复旦大学EMBA：揭秘科创企业，领略未来战略！

智能制造&#xff0c;国之重器。作为制造强国建设的主攻方向&#xff0c;智能制造的发展水平关系到我国未来制造业在全球的地位与影响力。发展智能制造&#xff0c;是加快建设现代化产业体系的重要手段&#xff0c;提升供给体系适配性的有力抓手&#xff0c;也是建设数字中国的…
阅读更多...
E. Monsters

E. Monsters

Problem - 1810E - Codeforces 思路&#xff1a;我们总结一下题意&#xff0c;能够得到这个题其实就是让我们从某个0开始搜索&#xff0c;然后看看是否可以遍历所有得节点&#xff0c;那么如果采用暴力得话那就是n^2logn&#xff0c;因为我们遍历一次使用优先队列得话是nlogn的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023