【经典算法】LeetCode25:K 个一组翻转链表(Java/C/Python3,Hard)

#算法

目录

  • 题目描述
  • 思路及实现
    • 方式一：递归
      • 思路
      • 代码实现
        • Java 版本
        • C 语言版本
        • Python3 版本
      • 复杂度分析
    • 方式二：迭代和原地反转
      • 思路
      • 代码实现
        • Java 版本
        • C 语言版本
        • Python3 版本
      • 复杂度分析
  • 总结
  • 相似题目

  • 标签：链表、递归

题目描述

给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。
k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。

示例 1：

输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：

输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
提示：
链表中的节点数目为 n
1 <= k <= n <= 5000
0 <= Node.val <= 1000
进阶：你可以设计一个只用 O(1) 额外内存空间的算法解决此问题吗？

原题：LeetCode 25

思路及实现

方式一：递归

思路

其大致过程可以分解为

  1. 找到待翻转的k个节点（注意：若剩余数量小于 k 的话，则不需要反转，因此直接返回待翻转部分的头结点即可）。
  2. 对其进行翻转。并返回翻转后的头结点（注意：翻转为左闭又开区间，所以本轮操作的尾结点其实就是下一轮操作的头结点）。
  3. 对下一轮 k 个节点也进行翻转操作。
  4. 将上一轮翻转后的尾结点指向下一轮翻转后的头节点，即将每一轮翻转的k的节点连接起来。

示意图

代码实现

Java 版本
/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {/*** 反转链表中每个大小为 k 的连续节点的子链表* @param head 当前子链表的头节点* @param k 指定的连续节点个数* @return 反转后的链表的头节点*/public ListNode reverseKGroup(ListNode head, int k) {if (head == null || head.next == null) {return head;}ListNode tail = head;for (int i = 0; i < k; i++) {// 如果剩余数量小于 k，则不需要反转。if (tail == null) {return head;}tail = tail.next;}// 反转前 k 个元素ListNode newHead = reverse(head, tail);// 下一轮的开始的地方就是 tailhead.next = reverseKGroup(tail, k);return newHead;}/*** 反转链表中左闭右开区间的节点* @param head 左闭区间的头节点* @param tail 右开区间的尾节点* @return 反转后的链表的头节点*/private ListNode reverse(ListNode head, ListNode tail) {ListNode pre = null;ListNode next = null;while (head != tail) {next = head.next;head.next = pre;pre = head;head = next;}return pre;}
}

说明：
reverseKGroup() 方法用于将链表每个大小为 k 的子列表进行反转。
如果输入的头节点 head 或其下一个节点为空，则无需翻转，直接返回头节点。
使用 tail 指针找到当前子列表的结束节点（即当前子列表的下一组的开始节点）。
如果剩余节点数量不足 k，则无需进行翻转，直接返回头节点。
调用 reverse() 方法反转当前子列表，并得到翻转后的新的头节点 newHead。
通过递归调用 reverseKGroup() 方法，将下一轮的开始位置 tail 作为参数传入。
将当前子列表的头节点 head 的 next 指针指向下一轮的结果，连接翻转后的下一组子列表。
返回翻转后的新的头节点 newHead。

C 语言版本
struct ListNode {int val;struct ListNode *next;
};/*** 反转以头节点head开始，尾节点为tail前一个节点的链表* 返回反转后的链表的头节点*/
struct ListNode* reverse(struct ListNode* head, struct ListNode* tail) {struct ListNode* prev = NULL;struct ListNode* curr = head;struct ListNode* next = NULL;while (curr != tail) {next = curr->next;curr->next = prev;prev = curr;curr = next;}return prev;
}/*** 反转每个大小为k的连续节点子链表* 返回修改后的链表的头节点*/
struct ListNode* reverseKGroup(struct ListNode* head, int k) {if (head == NULL || head->next == NULL) {return head;}struct ListNode* tail = head;for (int i = 0; i < k; i++) {// 如果剩余节点数不足k个，无需反转，直接返回头节点if (tail == NULL) {return head;}tail = tail->next;}// 反转前k个节点struct ListNode* newHead = reverse(head, tail);// 递归调用反转后续的子链表，并将结果连接到当前子链表的末尾head->next = reverseKGroup(tail, k);return newHead;
}

说明：
结构体 ListNode 定义了链表节点的结构，包含一个整型变量 val 和一个指向下一个节点的指针 next。
reverse() 函数用于反转以 head 节点为开始，以 tail 节点为前一个节点的子链表，并返回反转后的链表的头节点。
在 reverse() 函数中，使用三个指针 prev、curr 和 next 分别表示前一个节点、当前节点和下一个节点。
在 while 循环中，将当前节点 curr 的 next 指针指向前一个节点 prev，实现反转。
通过更新指针的位置，进行下一次的节点遍历。
返回反转后的链表的头节点 prev。
reverseKGroup() 函数用于反转每个大小为 k 的连续节点的子链表，并返回修改后的链表的头节点。
在 reverseKGroup() 函数中，如果输入的头节点 head 或其下一个节点为空，则无需反转，直接返回头节点。
使用指针 tail 找到当前子链表的结束节点（即当前子链表的下一组的开始节点）。
如果剩余节点数量不足 k，则无需反转，直接返回头节点。
调用 reverse() 函数反转当前子链表，并得到反转后的新头节点 newHead。
递归调用 reverseKGroup() 函数，对剩余的子链表进行反转，并将结果连接到当前子链表的末尾。
返回反转后的新头节点 newHead。

Python3 版本

class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef reverse(head: ListNode, tail: ListNode) -> ListNode:"""反转以head为头节点、tail为尾节点的子链表并返回反转后的链表的头节点"""prev = Nonecurr = headwhile curr != tail:next = curr.nextcurr.next = prevprev = currcurr = nextreturn prevdef reverseKGroup(head: ListNode, k: int) -> ListNode:"""反转每个大小为k的连续子链表并返回修改后的链表的头节点"""if not head or not head.next:return headtail = head# 找到子链表的尾节点for _ in range(k):if not tail:return headtail = tail.next# 反转子链表，并获取反转后的新的头节点new_head = reverse(head, tail)# 递归调用，将下一组子链表的头节点连接到当前子链表的末尾head.next = reverseKGroup(tail, k)return new_head

代码说明：
ListNode 类定义了链表节点的结构，包含一个整数类型变量 val 和一个指向下一个节点的指针 next。
reverse() 函数用于反转以 head 节点为开始，以 tail 节点为前一个节点的子链表，并返回反转后的链表的头节点。
在 reverse() 函数中，使用三个指针 prev、curr 和 next 分别表示前一个节点、当前节点和下一个节点。
在 while 循环中，将当前节点 curr 的 next 指针指向前一个节点 prev，实现反转。
通过更新指针的位置，进行下一次的节点遍历。
返回反转后的链表的头节点 prev。
reverseKGroup() 函数用于反转每个大小为 k 的连续节点的子链表，并返回修改后的链表的头节点。
在 reverseKGroup() 函数中，如果输入的头节点 head 或其下一个节点为空，则无需反转，直接返回头节点。
使用指针 tail 找到当前子链表的结束节点（即当前子链表的下一组的开始节点）。
如果剩余节点数量不足 k，则无需反转，直接返回头节点。
调用 reverse() 函数反转当前子链表，并得到反转后的新头节点 new_head。
递归调用 reverseKGroup() 函数，对剩余的子链表进行反转，并将结果连接到当前子链表的末尾。
返回反转后的新头节点 new_head。

复杂度分析

  • 时间复杂度：O(n)，其中 n 是链表的长度。每个节点都被遍历一次，每次遍历反转 k 个节点。

  • 空间复杂度：O(n/k)，递归调用栈的深度

方式二：迭代和原地反转

思路

迭代和原地反转的方法是通过遍历链表，对每个子链表进行原地反转，然后将反转后的子链表拼接到最终结果中。

代码实现

Java 版本
class Solution {/*** 反转以 head 为头节点的链表中的前 k 个节点* 返回反转后的头节点以及反转后的尾节点*/private ListNode reverseK(ListNode head, int k) {ListNode prev = null;ListNode curr = head;for (int i = 0; i < k; i++) {ListNode next = curr.next;curr.next = prev;prev = curr;curr = next;}return new ListNode[]{prev, head};}public ListNode reverseKGroup(ListNode head, int k) {ListNode dummy = new ListNode(0); // 创建一个虚拟头节点dummy.next = head;ListNode prev = dummy; // prev 始终指向每个子链表的反转前的最后一个节点ListNode curr = head; // curr 用于遍历链表while (curr != null) {ListNode tail = curr; // tail 保存每个子链表的最后一个节点int count = 0; // count 记录当前子链表的长度while (curr != null && count < k) {curr = curr.next;count++;}if (count < k) {// 如果剩余节点数不足 k，则不需要反转，直接跳出循环break;}ListNode[] result = reverseK(tail, k); // 反转当前子链表的前 k 个节点ListNode reversedHead = result[0]; // 反转后的头节点ListNode reversedTail = result[1]; // 反转后的尾节点// 将反转后的子链表接入链表prev.next = reversedHead;reversedTail.next = curr;prev = reversedTail; // 更新 prev 指针}return dummy.next;}
}

说明：
reverseK 方法用于反转以 head 为头节点的链表中的前 k 个节点。返回反转后的头节点和尾节点（这里使用了一个数组来返回多个节点）。
reverseKGroup 方法实现以 k 个一组翻转链表的功能。
创建一个虚拟头节点 dummy 来简化链表操作。
prev 指针始终指向每个子链表的反转前的最后一个节点。
curr 指针用于遍历链表。
使用循环遍历链表，直至 curr 为 null，这样可以处理剩余不足 k 个节点的情况。
在循环中，先找到当前子链表的最后一个节点 tail。
然后，再遍历 k 个节点，通过调用 reverseK 方法来反转这个子链表的前 k 个节点。
获取反转后的头节点 reversedHead 和尾节点 reversedTail。
将反转后的子链表接入链表中，即将 prev 的 next 指向 reversedHead，reversedTail 的 next 指向 curr。
更新 prev 指针，使其指向反转后的尾节点。

C 语言版本

struct ListNode {int val;struct ListNode *next;
};/*** 反转以 head 为头节点、tail 为尾节点的子链表* 并返回反转后的链表的头节点*/
struct ListNode* reverseLinkedList(struct ListNode* head, struct ListNode* tail) {struct ListNode* prev = NULL;struct ListNode* curr = head;while (curr != tail) {struct ListNode* next = curr->next;curr->next = prev;prev = curr;curr = next;}return prev;
}/*** 按照 k 个一组翻转链表* 并返回修改后的链表的头节点*/
struct ListNode* reverseKGroup(struct ListNode* head, int k) {struct ListNode* dummy = malloc(sizeof(struct ListNode)); // 创建一个虚拟头节点dummy->val = 0;dummy->next = head;struct ListNode* prev = dummy; // prev 始终指向每个子链表的反转前的最后一个节点struct ListNode* curr = head; // curr 用于遍历链表while (curr != NULL) {struct ListNode* tail = curr; // tail 保存每个子链表的最后一个节点int count = 0; // count 记录当前子链表的长度while (curr != NULL && count < k) {curr = curr->next;count++;}if (count < k) {break; // 如果剩余节点数不足 k，则不需要反转，直接跳出循环}struct ListNode* reversedHead = reverseLinkedList(tail, curr); // 反转当前子链表struct ListNode* reversedTail = tail;// 将反转后的子链表接入链表prev->next = reversedHead;reversedTail->next = curr;prev = reversedTail; // 更新 prev 指针}struct ListNode* newHead = dummy->next;free(dummy); // 释放虚拟头节点的内存return newHead;
}

说明：
reverseLinkedList 函数用于反转以 head 为头节点，以 tail 为前一个节点的子链表，并返回反转后的链表的头节点。
在 reverseLinkedList 函数中，使用两个指针 prev 和 curr 分别表示前一个节点和当前节点。
在 while 循环中，将当前节点 curr 的 next 指针指向前一个节点 prev，实现反转。
通过更新指针的位置，进行下一次的节点遍历。
返回反转后的链表的头节点 prev。
reverseKGroup 函数实现按照 k 个一组翻转链表的功能。
创建一个虚拟头节点 dummy 并将其指向链表的头部，以便于处理头节点的情况。
使用两个指针 prev 和 curr 分别指向当前子链表的最后一个节点和遍历节点。
在循环中，首先找到当前子链表的末尾节点 tail，然后再遍历 k 个节点。
如果剩余的节点数量不足 k 个，则不需要反转，直接退出循环。
调用 reverseLinkedList 函数反转当前子链表，并获取反转后的头节点 reversedHead 和尾节点 reversedTail。
将反转后的子链表接入链表中，即将 prev 的 next 指针指向 reversedHead，reversedTail 的 next 指针指向 curr。
更新 prev 指针，向后移动到反转后的子链表的尾节点。
返回虚拟头节点 dummy 的 next 指针，即为反转后的链表的头结点。

Python3 版本
class ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef reverseLinkedList(head: ListNode, tail: ListNode) -> ListNode:prev = Nonecurr = headwhile curr != tail:next_node = curr.nextcurr.next = prevprev = currcurr = next_nodereturn prevdef reverseKGroup(head: ListNode, k: int) -> ListNode:dummy = ListNode(0)  # 创建一个虚拟头节点dummy.next = headprev = dummy  # prev 始终指向每个子链表的反转前的最后一个节点curr = head  # curr 用于遍历链表while curr:tail = curr  # tail 保存每个子链表的最后一个节点count = 0  # count 记录当前子链表的长度while curr and count < k:curr = curr.nextcount += 1if count < k:break  # 如果剩余节点数不足 k，则不需要反转，直接跳出循环reversed_head = reverseLinkedList(tail, curr)  # 反转当前子链表reversed_tail = tail# 将反转后的子链表接入链表prev.next = reversed_headreversed_tail.next = currprev = reversed_tail  # 更新 prev 指针return dummy.next

说明：
reverseLinkedList 函数用于反转以 head 为头节点、tail 为尾节点的子链表，并返回反转后的链表的头节点。

在 reverseLinkedList 函数中，使用两个指针 prev 和 curr 分别表示前一个节点和当前节点。

在 while 循环中，将当前节点 curr 的 next 指针指向前一个节点 prev，实现反转。

通过更新指针的位置，进行下一次的节点遍历。

返回反转后的链表的头节点 prev。

reverseKGroup 函数用于按照 k 个一组翻转链表。

创建一个虚拟头节点 dummy 并将其指向链表的头部，以便于处理头节点的情况。

使用两个指针 prev 和 curr 分别指向当前子链表的最后一个节点和遍历节点。

在循环中，首先找到当前子链表的末尾节点 tail，然后再遍历 k 个节点。

如果剩余的节点数量不足 k 个，则不需要反转，直接退出循环。

调用 reverseLinkedList 函数反转子链表，并获取反转后的头节点和尾节点。

将反转后的子链表接入链表中，即将 prev 的 next 指针指向反转后的头节点，尾节点的 next 指针指向下一个子链表的头节点。

更新 prev 指针，向后移动到反转后的子链表的尾节点。

复杂度分析

  • 时间复杂度：O(n)，其中 n 是链表的长度。每个节点恰好被访问两次：一次是遍历整个链表，一次是进行反转操作。
  • 空间复杂度：O(1)。只使用了常数级别的额外空间来进行指针操作，没有使用额外的数据结构。

总结

递归法迭代+原地反转方法
思路将链表划分为大小为k的子链表，递归处理使用循环迭代遍历链表，并在每次迭代中原地反转子链表
时间复杂度O(n)，每个节点被遍历一次O(n)，每个节点被遍历一次
空间复杂度O(n/k)，递归调用栈的深度O(1)，原地修改链表
（如果递归栈的深度达到n/k，则创建了O(n/k)个递归调用栈帧）（不需要额外的空间，仅使用常数级别的指针变量和变量存储空间）
优点实现简单，逻辑清晰不需要额外的递归调用栈，适用于大规模链表
代码可读性好原地修改链表，不需要额外空间
缺点递归调用栈可能溢出实现相对复杂，需要处理指针的连接
额外的空间复杂度需要对子链表进行循环遍历和反转
特点可以处理较小规模的链表适用于大规模链表处理和优化空间复杂度
可读性好，思考和实现过程接近问题描述可读性相对较差，实现相对复杂

相似题目

相似题目力扣链接
反转链表 II力扣92
反转链表力扣206
K个一组翻转链表力扣25

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

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

相关文章

代码随想录阅读笔记-二叉树【总结】

代码随想录阅读笔记-二叉树【总结】

二叉树的理论基础 代码随想录 (programmercarl.com)&#xff1a;二叉树的种类、存储方式、遍历方式、定义方式 二叉树的遍历方式 深度优先遍历 代码随想录阅读笔记-二叉树【递归遍历】-CSDN博客&#xff1a;递归三部曲初次亮相代码随想录阅读笔记-二叉树【迭代遍历】-CSDN博…
阅读更多...
2024年3月文章一览

2024年3月文章一览

2024年3月编程人总共更新了12篇文章&#xff1a; 1.2024年2月文章一览 2.Programming Abstractions in C阅读笔记&#xff1a;p308-p311 3.Programming Abstractions in C阅读笔记&#xff1a;p312-p326 4.Programming Abstractions in C阅读笔记&#xff1a;p327-p330 5.…
阅读更多...
基于SSM的电影网站（有报告）。Javaee项目。ssm项目。

基于SSM的电影网站（有报告）。Javaee项目。ssm项目。

演示视频&#xff1a; 基于SSM的电影网站&#xff08;有报告&#xff09;。Javaee项目。ssm项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&#xff0c;通过Spring SpringMv…
阅读更多...
Ollama教程——兼容OpenAI API：高效利用兼容OpenAI的API进行AI项目开发

Ollama教程——兼容OpenAI API：高效利用兼容OpenAI的API进行AI项目开发

相关文章: Ollama教程——入门&#xff1a;开启本地大型语言模型开发之旅 Ollama教程——模型&#xff1a;如何将模型高效导入到ollama框架 Ollama教程——兼容OpenAI API&#xff1a;高效利用兼容OpenAI的API进行AI项目开发 Ollama教程——兼容OpenAI API&#xff1a;高效利用…
阅读更多...
L2-2 巴音布鲁克永远的土（二分+并查集）

L2-2 巴音布鲁克永远的土（二分+并查集）

思路&#xff1a;我们可以二分答案&#xff0c;然后判断当前答案合不合理。 对于判断答案合理&#xff0c;可以用并查集&#xff0c;看mid能否把所有检查点连进一个集合中&#xff0c;枚举每个结点&#xff0c;如何当前结点周围的四个方向可以连的话&#xff0c;就加进同一个集…
阅读更多...
【电子通识】热风枪的结构与使用方法

【电子通识】热风枪的结构与使用方法

热风枪的结构 热风枪是专门用来拆焊、焊接贴片元器件和贴片集成电路的焊接工具&#xff0c;它主要由主机和热风焊枪两大部分构成。 热风枪主要有电源开关、风速设置、温度设置、热风连接等部件组成。根据不同品牌和价位的热风枪&#xff0c;有一些功能齐全的也集成了烙铁功能。…
阅读更多...
波奇学Linux：

波奇学Linux：

面向数据报&#xff1a;udp没有发送缓冲区&#xff0c;发送几次数据报&#xff0c;读取几次数据报&#xff0c;write和read一一对应 tcp通信时只管识别数据&#xff0c;在应用层才对字节进行拼接分析&#xff0c;得到完整请求 简单来说&#xff1a;udp之间传递的是报文&#x…
阅读更多...
使用LNMP部署动态网站环境

使用LNMP部署动态网站环境

目录 实验环境 一、配置LNMP架构环境 二、验证部署的LNMP 动态网站环境是否可用 三、配置过程中遇到的问题及解决思路 实验环境 centos7 192.168.81.131/24 一、配置LNMP架构环境 概念及配置手册参考第20章 使用LNMP架构部署动态网站环境。 | 《Linux就该这么学》 安装g…
阅读更多...
三行命令解决Ubuntu Linux联网问题

三行命令解决Ubuntu Linux联网问题

本博客中Ubuntu版本为23.10.1最新版本&#xff0c;后续发现了很多问题我无法解决&#xff0c;已经下载了另外一个版本22.04&#xff0c;此版本自带网络 一开始我找到官方文档描述可以通过命令行连接到 WiFi 网络&#xff1a;https://cn.linux-console.net/?p10334#google_vig…
阅读更多...
漫画｜数据工程师面试常见问题之数据倾斜

漫画｜数据工程师面试常见问题之数据倾斜

话说&#xff0c;闹钟一响&#xff0c;现实照进梦想&#xff0c;又是李大虎面试找工作的一天。 李大虎心里一直有个想法&#xff0c;如果一天睡20个小时&#xff0c;然后这20个小时全做美梦&#xff0c;醒来的4个小时用来吃喝拉撒&#xff0c;这样岂不就和那些富二代一样了&am…
阅读更多...
【core analyzer】core analyzer的介绍和安装详情

【core analyzer】core analyzer的介绍和安装详情

目录 &#x1f31e;1. core和core analyzer的基本概念 &#x1f33c;1.1 coredump文件 &#x1f33c;1.2 core analyzer &#x1f31e;2. core analyzer的安装详细过程 &#x1f33c;2.1 方式一 简单但不推荐 &#x1f33c;2.2 方式二 推荐 &#x1f33b;2.2.1 安装遇到…
阅读更多...
【vue】v-if 条件渲染

【vue】v-if 条件渲染

v-if 不适用于频繁切换显示模式的场景 修改web.user&#xff0c;可看到条件渲染的效果 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initi…
阅读更多...
【MATLAB源码-第5期】基于matlab的BPSK的理论误码率和实际误码率对比仿真。

【MATLAB源码-第5期】基于matlab的BPSK的理论误码率和实际误码率对比仿真。

1、算法描述 BPSK (Binary Phase Shift Keying)-------二进制相移键控。是把模拟信号转换成数据值的转换方式之一&#xff0c;利用偏离相位的复数波浪组合来表现信息键控移相方式。BPSK使用了基准的正弦波和相位反转的波浪&#xff0c;使一方为0&#xff0c;另一方为1&#xf…
阅读更多...
Vue3大事件项目1 登录注册验证

Vue3大事件项目1 登录注册验证

创建项目 引入 element-ui 组件库 登录&#xff1a;注册样式准备之后&#xff0c;配置校验规则&#xff08;4个条件&#xff1a;一数据、二规则&#xff09; 1. 校验相关 (1) 给当前表单绑上整个的数据对象&#xff1a;el-form > :model"ruleForm" 绑…
阅读更多...
Centos7搭建 Skywalking 单机版

Centos7搭建 Skywalking 单机版

介绍 Skywalking是应用性能监控平台&#xff0c;可用于分布式系统&#xff0c;支持微服务、云原生、Docker、Kubernetes 等多种架构场景。 整体架构如图 Agent &#xff1a;在应用中&#xff0c;收集 Trace、Log、Metrics 等监控数据&#xff0c;使用 RPC、RESTful API、Kafk…
阅读更多...
JavaScript逆向爬虫——无限debugger的原理与绕过

JavaScript逆向爬虫——无限debugger的原理与绕过

debugger 是 JavaScript 中定义的一个专门用于断点调试的关键字&#xff0c;只要遇到它&#xff0c;JavaScript 的执行便会在此处中断&#xff0c;进入调试模式。 有了 debugger 这个关键字&#xff0c;就可以非常方便地对 JavaScript 代码进行调试&#xff0c;比如使用 JavaSc…
阅读更多...
【热门话题】计算机视觉入门：探索数字世界中的“视觉智能”

【热门话题】计算机视觉入门：探索数字世界中的“视觉智能”

&#x1f308;个人主页: 鑫宝Code &#x1f525;热门专栏: 闲话杂谈&#xff5c; 炫酷HTML | JavaScript基础 ​&#x1f4ab;个人格言: "如无必要&#xff0c;勿增实体" 文章目录 计算机视觉入门&#xff1a;探索数字世界中的“视觉智能”摘要正文一、计算机视…
阅读更多...
蓝桥杯练习题

蓝桥杯练习题

<1>搜一搜呀——filter 目标 请完善 index.html 文件&#xff0c;让页面具有如下所示的效果&#xff1a; 题解 computed: {filteredList() {// TODO: 请补充代码return this.postList.filter(post>{return post.title.match(this.search)})},}, 过滤器filter 定义…
阅读更多...
顺序表实战——基于顺序表的通讯录

顺序表实战——基于顺序表的通讯录

前言&#xff1a;本篇文章主要是利用顺序表作为底层&#xff0c; 实现一个通讯录。偏向于应用&#xff0c; 对于已经学习过c的友友们可能没有难度了已经。没有学习过c的友友&#xff0c; 如果顺序表不会写&#xff0c; 或者说没有自己实现过&#xff0c; 请移步学习顺序表相关内…
阅读更多...
springboot 问题整合

springboot 问题整合

springboot 启动后访问报错 问题&#xff1a;org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): 原因&#xff1a;mybatis 的全局配置文件和 sql 映射文件没有写 解决&#xff1a;在 application.yml 中添加 mybatis 配置 mybatis:# 全局配…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023