分享一款嵌入式开源按键框架代码工程MultiButton

目录

1 工程简介

2 工程代码分析

3 工程代码应用

4 思考

1 工程简介

        MultiButton 是一个小巧简单易用的事件驱动型按键驱动模块。

        Github地址：https://github.com/0x1abin/MultiButton

        这个项目非常精简，只有两个文件：

（1）可无限扩展按键；

（2）按键事件的回调异步处理方式可以简化程序结构，去除冗余的按键处理硬编码，让按键业务逻辑更清晰。

        通过此工程可以学习到以下知识点：

（1）按键各种类型事件

（2）状态机的思想

（3）单向链表语法

        MultiButton 支持如下的按键事件：

        MultiButton 的按键状态机软件流程图：

2 工程代码分析

        注：在使用源码工程时稍微修改了两个点，后续贴出完整代码，有需要查看修改的同学可以和将源码工程下载后进行对比，修改的点如下：

（1）将按键时间的相关参数通过接口定义进行初始化

（2）修改长按期间一直触发事件为真正的长按定时触发

        在头文件multi_button.h中：

（1）定义了按键时间相关参数

（2）定义了按键的事件类型

（3）定义按键链表结构体，这里使用了位域操作，解决字节的存储空间问题

#ifndef _MULTI_BUTTON_H_
#define _MULTI_BUTTON_H_

#include <stdint.h>
#include <string.h>


typedef struct ButtonPara {
	uint8_t ticks_interval;
	uint8_t debounce_ticks;
	uint16_t short_ticks;
	uint16_t long_ticks;
}ButtonPara;

typedef void (*BtnCallback)(void*);

typedef enum {
	PRESS_DOWN = 0,
	PRESS_UP,
	PRESS_REPEAT,
	SINGLE_CLICK,
	DOUBLE_CLICK,
	LONG_PRESS_START,
	LONG_PRESS_HOLD,
	number_of_event,
	NONE_PRESS
}PressEvent;

typedef struct Button {
	uint16_t ticks;
	uint8_t  repeat : 4;
	uint8_t  event : 4;
	uint8_t  state : 3;
	uint8_t  debounce_cnt : 3;
	uint8_t  active_level : 1;
	uint8_t  button_level : 1;
	uint8_t  button_id;
	uint8_t  (*hal_button_Level)(uint8_t button_id_);
	BtnCallback  cb[number_of_event];
	struct Button* next;
}Button;

#ifdef __cplusplus
extern "C" {
#endif
void button_para_init(struct ButtonPara para);
void button_init(struct Button* handle, uint8_t(*pin_level)(uint8_t), uint8_t active_level, uint8_t button_id);
void button_attach(struct Button* handle, PressEvent event, BtnCallback cb);
PressEvent get_button_event(struct Button* handle);
int  button_start(struct Button* handle);
void button_stop(struct Button* handle);
void button_ticks(void);

#ifdef __cplusplus
}
#endif

#endif

        在源码文件multi_button.c中：

（1）对按键时间参数进行初始化

（2）对按键对象结构体进行初始化，化成员包括按键句柄，绑定GPIO电平读取函数，设置有效触发电平

（3）初始化按键完成之后，进行按键绑定操作，将绑定按键结构体成员，按键触发事件，按键回调函数

（4）按键启动：也就是将按键加入链表当中，启动按键。这里选择的插入方式是头部插入法，在链表的头部插入按键节点。效率高，时间复杂度为O(1)

（5）按键删除，将按键从当前链表中删除。使用到了二级指针删除一个按键元素。与之前的多定时器删除方法相同

（6）按键滴答函数，每间隔Nms触发一次按键事件，驱动状态机运行。

（7）读取当前引脚的状态，获取按键当前属于哪种状态

（8）按键处理核心函数，驱动状态机

#include "multi_button.h"

#define EVENT_CB(ev)   if(handle->cb[ev])handle->cb[ev]((void*)handle)
#define PRESS_REPEAT_MAX_NUM  15 /*!< The maximum value of the repeat counter */

static struct ButtonPara buttonpara;
//button handle list head.
static struct Button* head_handle = NULL;

static void button_handler(struct Button* handle);


void button_para_init(struct ButtonPara para)
{
	buttonpara.ticks_interval = para.ticks_interval;
	buttonpara.debounce_ticks = para.debounce_ticks;
	buttonpara.short_ticks = para.short_ticks;
	buttonpara.long_ticks = para.long_ticks;
}
/**
  * @brief  Initializes the button struct handle.
  * @param  handle: the button handle struct.
  * @param  pin_level: read the HAL GPIO of the connected button level.
  * @param  active_level: pressed GPIO level.
  * @param  button_id: the button id.
  * @retval None
  */
void button_init(struct Button* handle, uint8_t(*pin_level)(uint8_t), uint8_t active_level, uint8_t button_id)
{
	memset(handle, 0, sizeof(struct Button));
	handle->event = (uint8_t)NONE_PRESS;
	handle->hal_button_Level = pin_level;
	handle->button_level = handle->hal_button_Level(button_id);
	handle->active_level = active_level;
	handle->button_id = button_id;
}

/**
  * @brief  Attach the button event callback function.
  * @param  handle: the button handle struct.
  * @param  event: trigger event type.
  * @param  cb: callback function.
  * @retval None
  */
void button_attach(struct Button* handle, PressEvent event, BtnCallback cb)
{
	handle->cb[event] = cb;
}

/**
  * @brief  Inquire the button event happen.
  * @param  handle: the button handle struct.
  * @retval button event.
  */
PressEvent get_button_event(struct Button* handle)
{
	return (PressEvent)(handle->event);
}

/**
  * @brief  Button driver core function, driver state machine.
  * @param  handle: the button handle struct.
  * @retval None
  */
static void button_handler(struct Button* handle)
{
	uint8_t read_gpio_level = handle->hal_button_Level(handle->button_id);

	//ticks counter working..
	if((handle->state) > 0) handle->ticks++;

	/*------------button debounce handle---------------*/
	if(read_gpio_level != handle->button_level) { //not equal to prev one
		//continue read 3 times same new level change
		if(++(handle->debounce_cnt) >= buttonpara.debounce_ticks) {
			handle->button_level = read_gpio_level;
			handle->debounce_cnt = 0;
		}
	} else { //level not change ,counter reset.
		handle->debounce_cnt = 0;
	}

	/*-----------------State machine-------------------*/
	switch (handle->state) {
	case 0:
		if(handle->button_level == handle->active_level) {	//start press down
			handle->event = (uint8_t)PRESS_DOWN;
			EVENT_CB(PRESS_DOWN);
			handle->ticks = 0;
			handle->repeat = 1;
			handle->state = 1;
		} else {
			handle->event = (uint8_t)NONE_PRESS;
		}
		break;

	case 1:
		if(handle->button_level != handle->active_level) { //released press up
			handle->event = (uint8_t)PRESS_UP;
			EVENT_CB(PRESS_UP);
			handle->ticks = 0;
			handle->state = 2;
		} else if(handle->ticks > buttonpara.long_ticks) {
			handle->event = (uint8_t)LONG_PRESS_START;
			EVENT_CB(LONG_PRESS_START);
			handle->state = 5;
		}
		break;

	case 2:
		if(handle->button_level == handle->active_level) { //press down again
			handle->event = (uint8_t)PRESS_DOWN;
			EVENT_CB(PRESS_DOWN);
			if(handle->repeat != PRESS_REPEAT_MAX_NUM) {
				handle->repeat++;
			}
			EVENT_CB(PRESS_REPEAT); // repeat hit
			handle->ticks = 0;
			handle->state = 3;
		} else if(handle->ticks > buttonpara.short_ticks) { //released timeout
			if(handle->repeat == 1) {
				handle->event = (uint8_t)SINGLE_CLICK;
				EVENT_CB(SINGLE_CLICK);
			} else if(handle->repeat == 2) {
				handle->event = (uint8_t)DOUBLE_CLICK;
				EVENT_CB(DOUBLE_CLICK); // repeat hit
			}
			handle->state = 0;
		}
		break;

	case 3:
		if(handle->button_level != handle->active_level) { //released press up
			handle->event = (uint8_t)PRESS_UP;
			EVENT_CB(PRESS_UP);
			if(handle->ticks < buttonpara.short_ticks) {
				handle->ticks = 0;
				handle->state = 2; //repeat press
			} else {
				handle->state = 0;
			}
		} else if(handle->ticks > buttonpara.short_ticks) { // SHORT_TICKS < press down hold time < LONG_TICKS
			handle->state = 1;
		}
		break;

	case 5:
		if(handle->button_level == handle->active_level) {
			//continue hold trigger
			if(handle->ticks > buttonpara.long_ticks) {
			handle->event = (uint8_t)LONG_PRESS_HOLD;
			EVENT_CB(LONG_PRESS_HOLD);
			handle->ticks = 0;
			}
		} else { //released
			handle->event = (uint8_t)PRESS_UP;
			EVENT_CB(PRESS_UP);
			handle->state = 0; //reset
		}
		break;
	default:
		handle->state = 0; //reset
		break;
	}
}

/**
  * @brief  Start the button work, add the handle into work list.
  * @param  handle: target handle struct.
  * @retval 0: succeed. -1: already exist.
  */
int button_start(struct Button* handle)
{
	struct Button* target = head_handle;
	while(target) {
		if(target == handle) return -1;	//already exist.
		target = target->next;
	}
	handle->next = head_handle;
	head_handle = handle;
	return 0;
}

/**
  * @brief  Stop the button work, remove the handle off work list.
  * @param  handle: target handle struct.
  * @retval None
  */
void button_stop(struct Button* handle)
{
	struct Button** curr;
	for(curr = &head_handle; *curr; ) {
		struct Button* entry = *curr;
		if(entry == handle) {
			*curr = entry->next;
//			free(entry);
			return;//glacier add 2021-8-18
		} else {
			curr = &entry->next;
		}
	}
}

/**
  * @brief  background ticks, timer repeat invoking interval 5ms.
  * @param  None.
  * @retval None
  */
void button_ticks(void)
{
	struct Button* target;
	for(target=head_handle; target; target=target->next) {
		button_handler(target);
	}
}

3 工程代码应用

以在freertos中应用中为例，包括：

（1）按键对象的定义及时间参数定义

（2）按键回调函数包括读取按键电平函数和各按键事件处理函数的编写

（2）按键初始化操作及启动按键功能

（4）在while(1)中添加按键滴答函数

#define TICKS_INTERVAL    5	//按键状态轮询周期，单位ms
#define DEBOUNCE_TICKS    3	//MAX 7 (0 ~ 7) 去抖时间次数，此为15ms/TICKS_INTERVAL=3次
#define SHORT_TICKS       (300 /TICKS_INTERVAL) //短按时间次数，300ms/TICKS_INTERVAL 
#define LONG_TICKS        (2000 /TICKS_INTERVAL) //长按时间次数，2000ms/TICKS_INTERVAL

						
enum Button_IDs {
	btn1_id,
	btn2_id,
	btn3_id,
};
struct ButtonPara btnpara = {TICKS_INTERVAL, DEBOUNCE_TICKS, SHORT_TICKS, LONG_TICKS};
struct Button btn1;
struct Button btn2;
struct Button btn3;

//According to your need to modify the constants.

uint8_t read_button_GPIO(uint8_t button_id)
{
	// you can share the GPIO read function with multiple Buttons
	switch(button_id)
	{
		case btn1_id:
			return GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_4);
		case btn2_id:
			return GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_3);
		case btn3_id:
			return GPIO_ReadInputDataBit(GPIOE,GPIO_Pin_2);
		default:
			return 0;
	}
}

void BTN1_PRESS_DOWN_Handler(void* btn)
{
	printf("BTN1_PRESS_DOWN_Handler!\r\n");
}

void BTN1_PRESS_UP_Handler(void* btn)
{
	printf("BTN1_PRESS_UP_Handler!\r\n");
}

void BTN1_PRESS_REPEAT_Handler(void* btn)
{
	printf("BTN1_PRESS_REPEAT_Handler, repeatcount = %d!\r\n",btn1.repeat);
}

void BTN1_SINGLE_Click_Handler(void* btn)
{
	printf("BTN1_SINGLE_Click_Handler!\r\n");
}

void BTN1_DOUBLE_Click_Handler(void* btn)
{
	printf("BTN1_DOUBLE_Click_Handler!\r\n");
}

void BTN1_LONG_PRESS_START_Handler(void* btn)
{
	printf("BTN1_LONG_PRESS_START_Handler!\r\n");
}

void BTN1_LONG_PRESS_HOLD_Handler(void* btn)
{
	printf("BTN1_LONG_PRESS_HOLD_Handler!\r\n");
}

void BTN2_SINGLE_Click_Handler(void* btn)
{
	printf("BTN2_SINGLE_Click_Handler!\r\n");
}

void BTN2_DOUBLE_Click_Handler(void* btn)
{
	printf("BTN2_DOUBLE_Click_Handler!\r\n");
}

void BTN3_LONG_PRESS_START_Handler(void* btn)
{
	printf("BTN3_LONG_PRESS_START_Handler!\r\n");
}

void BTN3_LONG_PRESS_HOLD_Handler(void* btn)
{
	printf("BTN3_LONG_PRESS_HOLD_Handler!\r\n");
}

int main(void)
{ 
	button_para_init(btnpara);
	button_init(&btn1, read_button_GPIO, 0, btn1_id);
	button_init(&btn2, read_button_GPIO, 0, btn2_id);
	button_init(&btn3, read_button_GPIO, 0, btn3_id);

	button_attach(&btn1, PRESS_DOWN,       BTN1_PRESS_DOWN_Handler);
	button_attach(&btn1, PRESS_UP,         BTN1_PRESS_UP_Handler);
	button_attach(&btn1, PRESS_REPEAT,     BTN1_PRESS_REPEAT_Handler);
	button_attach(&btn1, SINGLE_CLICK,     BTN1_SINGLE_Click_Handler);
	button_attach(&btn1, DOUBLE_CLICK,     BTN1_DOUBLE_Click_Handler);
	button_attach(&btn1, LONG_PRESS_START, BTN1_LONG_PRESS_START_Handler);
	button_attach(&btn1, LONG_PRESS_HOLD,  BTN1_LONG_PRESS_HOLD_Handler);

	button_attach(&btn2, PRESS_REPEAT,     BTN2_PRESS_REPEAT_Handler);
	button_attach(&btn2, SINGLE_CLICK,     BTN2_SINGLE_Click_Handler);
	button_attach(&btn2, DOUBLE_CLICK,     BTN2_DOUBLE_Click_Handler);
	
	button_attach(&btn3, LONG_PRESS_START, BTN3_LONG_PRESS_START_Handler);
	button_attach(&btn3, LONG_PRESS_HOLD,  BTN3_LONG_PRESS_HOLD_Handler);

	button_start(&btn1);
	button_start(&btn2);
	button_start(&btn3);
	

	xTaskCreate((TaskFunction_t )key_task,             
                (const char*    )"key_task",           
                (uint16_t       )KEY_STK_SIZE,        
                (void*          )NULL,                  
                (UBaseType_t    )KEY_TASK_PRIO,        
                (TaskHandle_t*  )&KeyTask_Handler);              
    vTaskStartScheduler();          
}


void key_task(void *pvParameters)
{
	while(1)
	{
		button_ticks();
		vTaskDelay(5);			//5ms周期轮询
	}
}

4 思考

        使用中有如下问题值得思考：

（1）组合键和矩阵按键如何实现？

        在函数uint8_t read_button_GPIO(uint8_t button_id)中进行组合键和矩阵按键返回值的自定义

（2）多个按键时，按键参数进行区分？

        去抖时间，短按时间，长按时间可以放在一个数组中区分，各个按键有各自的参数。

（3）按键事件较多的情况时，需要多个绑定的事件函数？

        按键事件函数可以统一放在一个数组中进行初始化注册。

↓↓↓更多技术内容和书籍资料获取，入群技术交流敬请关注“明解嵌入式”↓↓↓ 

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

前端layui自定义图标的简单使用

前端layui自定义图标的简单使用

iconfont-阿里巴巴矢量图标库 2. 3. 4.追加新图标 5.文件复制追加新图标
阅读更多...
OSPF实验

OSPF实验

需求&#xff1a; 1、R1-R3为区域0&#xff0c;R3到R4为区域1&#xff1b;其中R3的环回也在区域0&#xff0c;P1-R3分别有一个环回接口 2、R1-R3 R3为DR设备&#xff0c;没有BDR 3、R4环回地址已固定&#xff0c;其他所有网段使用192.168.1.0/24进行合理分配 4、R4环回不能…
阅读更多...
鸿蒙ArkUI声明式学习：【UI资源管理】

鸿蒙ArkUI声明式学习：【UI资源管理】

OpenHarmony 应用的资源分类和资源的访问以及应用开发使用的像素单位以及各单位之间相互转换的方法。 资源分类 移动端应用开发常用到的资源比如图片&#xff0c;音视频&#xff0c;字符串等都有固定的存放目录&#xff0c;OpenHarmony 把这些应用的资源文件统一放在 resourc…
阅读更多...
Golang中的上下文-context包的简介及使用

Golang中的上下文-context包的简介及使用

文章目录 简介context.Background()上下文取消函数上下文值传递建议Reference 简介 Go语言中的context包定义了一个名为Context的类型&#xff0c;它定义并传递截止日期、取消信号和其他请求范围的值&#xff0c;形成一个链式模型。如果我们查看官方文档&#xff0c;它是这样说…
阅读更多...
6.10物联网RK3399项目开发实录-驱动开发之SPI接口的使用（wulianjishu666）

6.10物联网RK3399项目开发实录-驱动开发之SPI接口的使用（wulianjishu666）

嵌入式实战开发例程&#xff0c;珍贵资料&#xff0c;开发必备&#xff1a; 链接&#xff1a;https://pan.baidu.com/s/1149x7q_Yg6Zb3HN6gBBAVA?pwdhs8b SPI 使用 SPI 简介 SPI 是一种高速的&#xff0c;全双工&#xff0c;同步串行通信接口&#xff0c;用于连接微控制器、…
阅读更多...
拥有自己的云环境-域名及备案

拥有自己的云环境-域名及备案

序 唠叨两句 之前的文章&#xff0c;讲了如何购买一台云服务器&#xff0c;然后购买之后&#xff0c;如何操作云服务器。当买完云服务器之后&#xff0c;我们就可以使用云服务器提供的公网ip&#xff0c;访问到我们的服务器上。但是&#xff0c;这样怎么能体现我们一个老程序…
阅读更多...
第十四届蓝桥杯岛屿个数

第十四届蓝桥杯岛屿个数

题目描述&#xff1a; 小蓝得到了一副大小为 MN 的格子地图&#xff0c;可以将其视作一个只包含字符 0&#xff08;代表海水&#xff09;和 1&#xff08;代表陆地&#xff09;的二维数组&#xff0c;地图之外可以视作全部是海水&#xff0c;每个岛屿由在上/下/左/右四个方向上…
阅读更多...
使用 AI 生成正则表达式，告别正则烦恼

使用 AI 生成正则表达式，告别正则烦恼

如果你有处理正则表达式的需求&#xff0c;那么这个网站&#xff08;autoregex.xyz&#xff09;一定要收藏好。 可以根据文字描述生成正则表达式。 默认是从文字到正则&#xff0c;不用选择。 输入框中输入描述&#xff0c;点击 ”GO“ 按钮。 等待一会儿&#xff0c;即可生…
阅读更多...
测试开发面经（Flask,轻量级Web框架）

测试开发面经（Flask,轻量级Web框架）

1. Flask的核心特点 a. 轻量级&#xff1a;核心简洁&#xff0c;只提供了基本的功能&#xff0c;其他高级功能可以通过插件或扩展来添加。 b. 灵活性&#xff1a;允许开发者选择适合自己项目的组件和工具&#xff0c;没有强制的项目结构和设计模式。 c. 易于扩展&#xff1a;提…
阅读更多...
搭建python编译环境

搭建python编译环境

目录 1.安装依赖包 2.安装失败进行换源 3. 更新系统 通过C 语言调用 Python 代码&#xff0c;需要先安装 libpython3 的 dev 依赖库&#xff08;不同的 ubuntu 版本下&#xff0c; python 版本 可能会有差异&#xff0c; 比如ubuntu 22.04 里是 libpython3.10-dev &#xff09…
阅读更多...
javaScript手写专题——实现instanceof/call/apply/bind/new的过程/继承方式

javaScript手写专题——实现instanceof/call/apply/bind/new的过程/继承方式

目录 原型链相关 手写instanceof 实现一个_instance方法&#xff0c;判断对象obj是否是target的实例 测试 手写new的过程 实现一个myNew方法&#xff0c;接收一个构造函数以及构造函数的参数&#xff0c;返回构造函数创建的实例对象 测试myNew方法 手写类的继承 ES6&…
阅读更多...
人民大学：揭示大语言模型事实召回的关键机制

人民大学：揭示大语言模型事实召回的关键机制

引言&#xff1a;大语言模型事实召回机制探索 该论文深入研究了基于Transformer的语言模型在零射击和少射击场景下的事实记忆任务机制。模型通过任务特定的注意力头部从语境中提取主题实体&#xff0c;并通过多层感知机回忆所需答案。作者提出了一种新的分析方法&#xff0c;可…
阅读更多...
dll文件丢失怎么恢复，教你5种简单有效的方法

dll文件丢失怎么恢复，教你5种简单有效的方法

在计算机系统的运行过程中&#xff0c;动态链接库&#xff08;DLL&#xff09;文件扮演着至关重要的角色。它们作为共享函数库&#xff0c;封装了大量的可重用代码&#xff0c;使得多个应用程序能够高效调用并执行特定功能&#xff0c;极大地节省了系统资源&#xff0c;提升了软…
阅读更多...
Arduino开发 esp32cam＋opencv人脸识别距离+语音提醒

Arduino开发 esp32cam＋opencv人脸识别距离+语音提醒

效果 低于20厘米语音提醒字体变红 QQ录屏20240406131651 Arduino代码 可直接复制使用&#xff08;修改自己的WIFI) #include <esp32cam.h> #include <WebServer.h> #include <WiFi.h> // 设置要连接的WiFi名称和密码 const char* WIFI_SSID "gumou&q…
阅读更多...
指针的深入理解（六）

指针的深入理解（六）

指针的深入理解&#xff08;六&#xff09; 个人主页&#xff1a;大白的编程日记 感谢遇见&#xff0c;我们一起学习进步&#xff01; 文章目录 指针的深入理解&#xff08;六&#xff09;前言一. sizeof和strlen1.1sizeof1.2strlen1.3sizeof和strlen对比 二.数组名和指针加减…
阅读更多...
动态代理

动态代理

动态代理 动态代理和静态代理角色一致。 代理类是动态生成的，不是我们直接写好的。 动态代理分为俩大类：基于接口的动态代理、基于类的动态代理 基于接口：JDK动态代理（以下示例就是这个） 基于类：cglib java字节码实现：javasist JDK动态代理 InvocationHandler Proxy …
阅读更多...
C语言从入门到实战————编译和链接

C语言从入门到实战————编译和链接

目录 前言 1. 翻译环境和运行环境 2. 翻译环境 2.1 预处理&#xff08;预编译&#xff09; 2.2 编译 2.2.1 词法分析&#xff1a; 2.2.2 语法分析 2.2.3 语义分析 2.3 汇编 2.4 链接 3. 运行环境 前言 编译和链接是将C语言源代码转换成可执行文件的必经过程&a…
阅读更多...
分公司=-部门--组合模式

分公司=-部门--组合模式

1.1 分公司不就是一部门吗&#xff1f; "我们公司最近接了一个项目&#xff0c;是为一家在全国许多城市都有分销机构的大公司做办公管理系统&#xff0c;总部有人力资源、财务、运营等部门。" "这是很常见的OA系统&#xff0c;需求分析好的话&#xff0…
阅读更多...
Linux 内核移植exfat驱动

Linux 内核移植exfat驱动

简介&#xff1a; Linux系统默认可以自动识别到fat32格式的盘&#xff0c;但fat32支持的文件不能大于4G&#xff0c;所以只能将移动硬盘和U盘格式化为NTFS和exFAT这两种格式的&#xff0c;对于U盘最好格式化为exFAT。 Linux5.4以上的内核原生支持exfat格式&#xff0c;不需要你…
阅读更多...
【LeetCode: 572. 另一棵树的子树 + 二叉树 + dfs】

【LeetCode: 572. 另一棵树的子树 + 二叉树 + dfs】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023