算法刷题记录——LeetCode篇(1.3) [第21~30题](持续更新)

更新时间：2025-03-29

  • LeetCode题解专栏：实战算法解题 (专栏)
  • 技术博客总目录：计算机技术系列目录页

优先整理热门100及面试150，不定期持续更新，欢迎关注！

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

  • 两个链表的节点数目范围是 [0, 50]
  • -100 <= Node.val <= 100
  • l1 和 l2 均按 非递减顺序 排列

方法一：迭代法

使用迭代法合并两个有序链表，通过创建一个 哑节点(dummy node) 作为新链表的起始点，逐步比较两个链表的当前节点值，将较小的节点连接到新链表中，直到其中一个链表遍历完毕，然后将剩余链表直接链接到新链表的尾部。

  1. 初始化：创建哑节点 dummy 和当前指针 curr，初始时 curr 指向 dummy。
  2. 遍历比较：
    • 当两个链表均不为空时，比较它们的当前节点值。
    • 将较小的节点链接到 curr.next，并移动对应的链表指针。
    • 移动 curr 到下一个位置。
  3. 处理剩余节点：将非空链表直接链接到 curr.next。
  4. 返回结果：返回 dummy.next 作为合并后的链表头节点。

代码实现(Java)：

class Solution {public ListNode mergeTwoLists(ListNode list1, ListNode list2) {ListNode dummy = new ListNode(-1);ListNode curr = dummy;while (list1 != null && list2 != null) {if (list1.val <= list2.val) {curr.next = list1;list1 = list1.next;} else {curr.next = list2;list2 = list2.next;}curr = curr.next;}curr.next = list1 != null ? list1 : list2;return dummy.next;}
}

复杂度分析：

  • 时间复杂度：O(m + n)，其中 m 和 n 分别为两个链表的长度。
  • 空间复杂度：O(1)，仅使用固定大小的额外空间。

方法二：递归法

递归法通过比较两个链表头节点的值，将较小节点的 next 指针指向剩余链表合并的结果，递归终止条件为其中一个链表为空时直接返回另一个链表。

  1. 终止条件：
    • 若 list1 为空，返回 list2。
    • 若 list2 为空，返回 list1。
  2. 递归合并：
    • 比较两个链表头节点的值，较小节点的 next 指向递归合并后的结果。
    • 返回较小的节点作为当前子链表的头节点。

代码实现(Java)：

class Solution {public ListNode mergeTwoLists(ListNode list1, ListNode list2) {if (list1 == null) return list2;if (list2 == null) return list1;if (list1.val <= list2.val) {list1.next = mergeTwoLists(list1.next, list2);return list1;} else {list2.next = mergeTwoLists(list1, list2.next);return list2;}}
}

复杂度分析：

  • 时间复杂度：O(m + n)，递归遍历所有节点。
  • 空间复杂度：O(m + n)，递归调用栈的深度最大为两链表长度之和。

对比总结

方法优点缺点适用场景
迭代法空间复杂度低，无递归开销代码相对较长处理大规模链表时更优
递归法代码简洁，逻辑清晰空间复杂度高，可能栈溢出链表较短或对代码简洁性要求高时

22. 括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。

示例 1：

输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]

示例 2：

输入：n = 1
输出：["()"]

提示：

  • 1 <= n <= 8

方法一：回溯法（深度优先搜索）

通过递归生成所有可能的有效括号组合，优先添加左括号并在条件允许时添加右括号，确保右括号数量不超过左括号。

代码实现(Java)：

public class Solution {public List<String> generateParenthesis(int n) {List<String> res = new ArrayList<>();backtrack(res, new StringBuilder(), 0, 0, n);return res;}private void backtrack(List<String> res, StringBuilder current, int left, int right, int n) {if (current.length() == 2 * n) {res.add(current.toString());return;}if (left < n) {current.append('(');backtrack(res, current, left + 1, right, n);current.deleteCharAt(current.length() - 1); // 回溯}if (right < left) {current.append(')');backtrack(res, current, left, right + 1, n);current.deleteCharAt(current.length() - 1); // 回溯}}
}

复杂度分析：

  • 时间复杂度： O(4^n / √n)，由卡塔兰数公式决定，每个组合的生成时间为 O(1) 均摊。
  • 空间复杂度： O(n)，递归栈深度最大为 2n，字符串长度最多为 2n。

方法二：动态规划（递推构造）

利用已知较小规模的结果递推生成较大规模的结果，将问题分解为内部和外部括号组合的拼接。

代码实现(Java)：

public class Solution {public List<String> generateParenthesis(int n) {List<List<String>> dp = new ArrayList<>();dp.add(List.of("")); // dp[0] 初始化为空字符串for (int i = 1; i <= n; i++) {List<String> current = new ArrayList<>();for (int k = 0; k < i; k++) {// 内部 k 对括号，外部 i-1-k 对括号for (String inner : dp.get(k)) {for (String outer : dp.get(i - 1 - k)) {current.add("(" + inner + ")" + outer);}}}dp.add(current);}return dp.get(n);}
}

复杂度分析：

  • 时间复杂度： O(n^2 * C(n))，C(n) 为卡塔兰数，需要多层嵌套循环。
  • 空间复杂度： O(n * C(n))，存储所有中间结果。

方法三：迭代法（广度优先搜索）

用队列保存中间状态，逐步扩展每个可能的括号组合，直到达到目标长度。

代码实现(Java)：

public class Solution {static class Node {String str;int left;int right;public Node(String s, int l, int r) {str = s;left = l;right = r;}}public List<String> generateParenthesis(int n) {List<String> res = new ArrayList<>();Queue<Node> queue = new LinkedList<>();queue.offer(new Node("", 0, 0));while (!queue.isEmpty()) {Node node = queue.poll();if (node.str.length() == 2 * n) {res.add(node.str);continue;}if (node.left < n) {queue.offer(new Node(node.str + "(", node.left + 1, node.right));}if (node.right < node.left) {queue.offer(new Node(node.str + ")", node.left, node.right + 1));}}return res;}
}

复杂度分析：

  • 时间复杂度： O(4^n / √n)，与回溯法相同。
  • 空间复杂度： O(4^n / √n)，队列中存储所有中间状态的字符串。

对比总结

  1. 回溯法 是最高效的实现，直接通过剪枝避免无效路径，代码简洁。
  2. 动态规划 思路巧妙，但空间占用较大，适合研究问题分解的规律。
  3. 迭代法（BFS） 无递归栈溢出风险，适合需要迭代实现的场景。

23. 合并 K 个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]

解释：链表数组如下,
[1->4->5, 1->3->4, 2->6]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

  • k == lists.length
  • 0 <= k <= 10^4
  • 0 <= lists[i].length <= 500
  • -10^4 <= lists[i][j] <= 10^4
  • lists[i] 按 升序 排列
  • lists[i].length 的总和不超过 10^4

方法一：分治合并（递归）

将链表数组递归地分成两半，分别合并左右两半，再将结果合并。利用分治策略降低时间复杂度，每次合并两个有序链表。

  1. 递归终止：当链表数组为空或只有一个链表时返回。
  2. 分治处理：找到中间位置，递归合并左右两半。
  3. 合并结果：将递归得到的两个有序链表合并。

代码实现(Java)：

class Solution {public ListNode mergeKLists(ListNode[] lists) {if (lists == null || lists.length == 0) return null;return merge(lists, 0, lists.length - 1);}private ListNode merge(ListNode[] lists, int start, int end) {if (start == end) return lists[start];int mid = start + (end - start) / 2;ListNode left = merge(lists, start, mid);ListNode right = merge(lists, mid + 1, end);return mergeTwoLists(left, right);}private ListNode mergeTwoLists(ListNode l1, ListNode l2) {ListNode dummy = new ListNode(0);ListNode curr = dummy;while (l1 != null && l2 != null) {if (l1.val < l2.val) {curr.next = l1;l1 = l1.next;} else {curr.next = l2;l2 = l2.next;}curr = curr.next;}curr.next = (l1 != null) ? l1 : l2;return dummy.next;}
}

复杂度分析：

  • 时间复杂度：O(nk logk)，其中 n 是平均链表长度，k 是链表数量。
  • 空间复杂度：O(logk)，递归调用栈的深度。

方法二：分治合并（迭代）

通过迭代方式逐步合并相邻链表，避免递归栈开销。每次将链表两两合并，直到只剩一个链表。

  1. 初始化处理：直接处理链表数组。
  2. 逐步合并：每次合并相邻两个链表，缩小数组范围。
  3. 最终合并：循环直到数组只剩一个链表。

代码实现(Java)：

class Solution {public ListNode mergeKLists(ListNode[] lists) {if (lists == null || lists.length == 0) return null;int k = lists.length;while (k > 1) {int idx = 0;for (int i = 0; i < k; i += 2) {ListNode l1 = lists[i];ListNode l2 = (i + 1 < k) ? lists[i + 1] : null;lists[idx++] = mergeTwoLists(l1, l2);}k = idx;}return lists[0];}private ListNode mergeTwoLists(ListNode l1, ListNode l2) {ListNode dummy = new ListNode(0);ListNode curr = dummy;while (l1 != null && l2 != null) {if (l1.val < l2.val) {curr.next = l1;l1 = l1.next;} else {curr.next = l2;l2 = l2.next;}curr = curr.next;}curr.next = (l1 != null) ? l1 : l2;return dummy.next;}
}

复杂度分析：

  • 时间复杂度：O(nk logk)。
  • 空间复杂度：O(1)，无额外递归栈空间。

方法三：优先队列（最小堆）

利用最小堆维护当前所有链表的最小节点。每次取出堆顶节点，将其下一节点加入堆中，直到堆为空。

  1. 初始化堆：将所有非空链表头节点加入堆。
  2. 构建结果：不断取出堆顶节点，链接到结果链表。
  3. 维护堆：将取出节点的下一节点入堆。

代码实现(Java)：

class Solution {public ListNode mergeKLists(ListNode[] lists) {if (lists == null || lists.length == 0) return null;PriorityQueue<ListNode> heap = new PriorityQueue<>((a, b) -> a.val - b.val);for (ListNode node : lists) {if (node != null) heap.offer(node);}ListNode dummy = new ListNode(0);ListNode curr = dummy;while (!heap.isEmpty()) {ListNode minNode = heap.poll();curr.next = minNode;curr = curr.next;if (minNode.next != null) {heap.offer(minNode.next);}}return dummy.next;}
}

复杂度分析：

  • 时间复杂度：O(nk logk)。
  • 空间复杂度：O(k)，堆存储最多k个节点。

对比总结

方法优点缺点适用场景
分治合并（递归）代码简洁，逻辑清晰递归栈空间O(logk)常规场景，k较小
分治合并（迭代）无栈溢出风险，空间最优修改原数组结构k较大的场景，空间敏感
优先队列实现简单，直观堆空间O(k)k较小的场景，链表较短

24. 两两交换链表中的节点

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

  • 链表中节点的数目在范围 [0, 100] 内
  • 0 <= Node.val <= 100

方法：迭代法

通过迭代遍历链表，每次交换相邻两个节点。使用哑节点简化头节点处理，维护前驱指针current，每次交换current后的两个节点，并更新current的位置。

  1. 初始化哑节点：避免处理头节点交换的特殊情况。
  2. 遍历条件：当前节点后存在两个可交换节点。
  3. 节点交换：
    • 保存当前两个节点及后续节点。
    • 调整指针指向完成交换。
  4. 移动前驱指针：前驱指针移动到已交换对的第二个节点，继续后续操作。

代码实现(Java)：

class Solution {public ListNode swapPairs(ListNode head) {ListNode dummy = new ListNode(-1);dummy.next = head;ListNode current = dummy;while (current.next != null && current.next.next != null) {// 获取要交换的两个节点ListNode first = current.next;ListNode second = first.next;ListNode next = second.next;// 交换节点current.next = second;second.next = first;first.next = next;// 移动current指针到已交换对的第二个节点，作为下一轮的前驱current = first;}return dummy.next;}
}

复杂度分析

  • 时间复杂度：O(n)，每个节点仅遍历一次。
  • 空间复杂度：O(1)，仅使用常量额外空间。

25. K 个一组翻转链表

给你链表的头节点 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

方法一：迭代法

通过迭代遍历链表，每次处理k个节点组成的子链表。使用哑节点简化头节点处理，维护前驱指针pre，每次找到当前组的首尾节点后进行反转，并重新连接链表。

  1. 初始化哑节点：避免处理头节点反转的特殊情况。
  2. 寻找当前组的尾节点：通过循环k次定位当前组的结束位置。
  3. 反转子链表：将当前组的k个节点反转，返回新的头和尾。
  4. 重新连接链表：将前驱节点连接到反转后的头，反转后的尾连接到下一组的头。
  5. 更新指针：将前驱指针移动到当前组的尾，继续处理后续节点。

代码实现(Java)：

class Solution {public ListNode reverseKGroup(ListNode head, int k) {ListNode dummy = new ListNode(0);dummy.next = head;ListNode pre = dummy;ListNode end = dummy;while (end.next != null) {// 定位当前组的尾节点for (int i = 0; i < k; i++) {end = end.next;if (end == null) return dummy.next; // 不足k个直接返回}// 记录关键节点ListNode start = pre.next;ListNode nextGroup = end.next;end.next = null; // 断开当前组// 反转当前组并连接pre.next = reverse(start);start.next = nextGroup; // 原start变为当前组的尾// 更新指针pre = start;end = pre;}return dummy.next;}// 反转链表并返回新头节点private ListNode reverse(ListNode head) {ListNode prev = null;ListNode curr = head;while (curr != null) {ListNode next = curr.next;curr.next = prev;prev = curr;curr = next;}return prev;}
}

复杂度分析：

  • 时间复杂度：O(n)，每个节点被处理两次（遍历和反转）。
  • 空间复杂度：O(1)，仅使用常量额外空间。

方法二：递归法

递归处理每个分组，先判断剩余节点是否足够k个，若足够则反转前k个节点，递归处理后续链表，并将当前尾节点与后续结果连接。

  1. 检查剩余长度：遍历k次判断是否足够反转。
  2. 反转当前组：反转前k个节点。
  3. 递归后续链表：将当前尾节点的next指向递归处理后的结果。
  4. 返回新头节点：当前组的头节点变为反转后的首节点。

代码实现(Java)：

class Solution {public ListNode reverseKGroup(ListNode head, int k) {ListNode curr = head;int count = 0;// 检查是否有足够k个节点while (curr != null && count < k) {curr = curr.next;count++;}if (count == k) { // 足够k个则反转ListNode reversedHead = reverse(head, k);head.next = reverseKGroup(curr, k); // 原head变为当前组的尾return reversedHead;}return head; // 不足k个直接返回}// 反转前k个节点private ListNode reverse(ListNode head, int k) {ListNode prev = null;ListNode curr = head;while (k-- > 0) {ListNode next = curr.next;curr.next = prev;prev = curr;curr = next;}return prev;}
}

复杂度分析：

  • 时间复杂度：O(n)，每个节点被处理一次。
  • 空间复杂度：O(n/k)，递归栈深度为分组数。

26. 删除有序数组中的重复项

给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。

考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：

  • 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
  • 返回 k 。

系统会用下面的代码来测试你的题解：

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案
int k = removeDuplicates(nums); // 调用
assert k == expectedNums.length;
for (int i = 0; i < k; i++) {assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被 通过。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]

解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]

解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：

  • 1 <= nums.length <= 3 * 10^4
  • -10^4 <= nums[i] <= 10^4
  • nums 已按 非严格递增 排列

方法：双指针法

使用快慢双指针，快指针遍历数组，慢指针记录不重复元素的位置。当遇到不重复元素时，将其移至慢指针的下一个位置，并更新慢指针。由于数组已排序，只需比较相邻元素即可。

  1. 处理空数组的特殊情况。
  2. 初始化慢指针 slow 为0。
  3. 快指针 fast 从1开始遍历数组：
    • 当 nums[fast] != nums[slow]，移动慢指针并更新其值。
  4. 返回 slow + 1 作为唯一元素的个数。

代码实现(Java)：

class Solution {public int removeDuplicates(int[] nums) {if (nums.length == 0) return 0;int slow = 0;for (int fast = 1; fast < nums.length; fast++) {if (nums[fast] != nums[slow]) {slow++;nums[slow] = nums[fast];}}return slow + 1;}
}

复杂度分析：

  • 时间复杂度：O(n)，只需一次遍历数组。
  • 空间复杂度：O(1)，原地修改，仅使用常数空间。

27. 移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。

假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：

更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。

评测机将使用以下代码测试您的解决方案：

int[] nums = [...]; // 输入数组
int val = ...; // 要移除的值
int[] expectedNums = [...]; // 长度正确的预期答案。
int k = removeElement(nums, val); // 调用你的实现
assert k == expectedNums.length;
sort(nums, 0, k); // 排序 nums 的前 k 个元素
for (int i = 0; i < actualLength; i++) {assert nums[i] == expectedNums[i];
}

如果所有的断言都通过，你的解决方案将会 通过。

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]

解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,_,_,_]

解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

提示：

  • 0 <= nums.length <= 100
  • 0 <= nums[i] <= 50
  • 0 <= val <= 100

方法：快慢双指针法

使用快慢指针遍历数组，快指针检查每个元素是否等于目标值。当遇到不等于目标值的元素时，将其复制到慢指针位置，并移动慢指针。最终慢指针的位置即为新数组长度。

  1. 初始化慢指针：index 记录有效元素位置，初始为0。
  2. 快指针遍历：快指针 i 遍历数组，遇到非目标值时，复制到 index 位置并移动慢指针。
  3. 返回结果：慢指针位置即为新长度。

代码实现(Java)：

class Solution {public int removeElement(int[] nums, int val) {int index = 0;for (int i = 0; i < nums.length; i++) {if (nums[i] != val) {nums[index++] = nums[i];}}return index;}
}

复杂度分析：

  • 时间复杂度：O(n)，仅需一次遍历。
  • 空间复杂度：O(1)，原地修改数组，无需额外空间。

声明

  1. 本文版权归 CSDN 用户 Allen Wurlitzer 所有，遵循CC-BY-SA协议发布，转载请注明出处。
  2. 本文题目来源 力扣-LeetCode ，著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

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

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

相关文章

常用数据库

常用数据库

模式的定义于删除 1.定义模式 CREATE SCHEMA [ <模式名> ] AUTHORIZATION < 用户名 >;要创建模式&#xff0c;调用该命令的用户必须拥有数据库管理员权限&#xff0c;或者获得了DBA授权 eg:为用户WANG定义一个模式S-C-SC CREATE SCHEMA "S-C-SC" AUT…
阅读更多...
Processor System Reset IP 核 v5.0（vivado）

Processor System Reset IP 核 v5.0（vivado）

这个IP的作用&#xff0c;我的理解是&#xff0c;比普通按键复位更加高效灵活&#xff0c;可以配置多个复位输出&#xff0c;可以配置复位周期。 1、输入信号&#xff1a; 重要的信号有时钟clk信号&#xff0c;一般连接到系统时钟&#xff1b;输入复位信号&#xff0c;一般是外…
阅读更多...
3月29日星期六今日早报简报微语报早读

3月29日星期六今日早报简报微语报早读

3月29日星期六&#xff0c;农历三月初一&#xff0c;早报#微语早读。 1、全国公立医疗机构自3月31日起全面停止收取门诊预交金&#xff1b; 2、永辉超市“胖东来调改店”已达47家店 一线员工薪酬涨幅50%以上&#xff1b; 3、两孩家庭补10万&#xff0c;三孩家庭补20万&#…
阅读更多...
pyinstaller 对 pyexecjs模块打包老会有终端框闪烁

pyinstaller 对 pyexecjs模块打包老会有终端框闪烁

解决办法&#xff1a; 修改 execjs 源代码 具体步骤 1. 在 execjs 源文件中&#xff0c;找到 _external_runtime.py 文件中的以下代码 p Popen(cmd, startupinfostartupinfo, stdinPIPE, stdoutPIPE, stderrPIPE, cwdself._cwd,universal_newlinesTrue)2. 修改为&#xff…
阅读更多...
代码随想录day2 数组总结

代码随想录day2 数组总结

1.二分查找 2.快慢 双指针 代码随想录day1-CSDN博客 3.滑动窗口 滑动窗口就是有一个起始位置&#xff0c;一个终止位置&#xff0c;通过调节起始位置和终止位置得到我们想要的结果。 外面一层for循环 用来更新终止位置 不满足条件 终止位置右移 里面一层while循环 …
阅读更多...
MAC安装docker 后提示com.docker.vmnetd”将对您的电脑造成伤害

MAC安装docker 后提示com.docker.vmnetd”将对您的电脑造成伤害

出现“com.docker.vmnetd”将对您的电脑造成伤害的提示&#xff0c;通常是由于文件签名问题导致 macOS 的安全系统误判 Docker 为恶意软件。以下是解决方法&#xff1a; 停止相关服务并删除文件 运行以下命令停止相关服务并删除有问题的文件 停止 Docker 服务 sudo pkill ‘…
阅读更多...
Redis-常用命令

Redis-常用命令

目录 1、Redis数据结构 2、命令简介 2.1、通用命令 DEL EXISTS EXPIRE 2.2、String命令 SET和GET MSET和MGET INCR和INCRBY和DECY SETNX SETEX 2.3、Key的层级结构 2.4、Hash命令 HSET和HGET HMSET和HMGET HGETALL HKEYS和HVALS HINCRBY HSETNX 2.5、List命…
阅读更多...
每日一题之既约分数

每日一题之既约分数

题目描述 本题为填空题&#xff0c;只需要算出结果后&#xff0c;在代码中使用输出语句将所填结果输出即可。 如果一个分数的分子和分母的最大公约数是 1&#xff0c;这个分数称为既约分数。 例如 3/4,1/8,7/1​&#xff0c; 都是既约分数。 请问&#xff0c;有多少个既约分…
阅读更多...
Java 图片压缩：高效压缩方案解析

Java 图片压缩：高效压缩方案解析

目录 一、基于OpenCV的智能尺寸压缩（一）代码示例（二）技术亮点（三）适用场景二、WebP高效格式转换（一）代码示例（二）核心优势（三）性能对比三、基于Thumbnailator的简单压缩（一）代码示例（二）技术亮点（三）适用场景四、方案选型建议一、基于OpenCV的智能尺寸压缩 …
阅读更多...
鸿蒙Next-集成HmRouter的路由模式

鸿蒙Next-集成HmRouter的路由模式

第一步&#xff1a;全局安装hmrouter依赖 ohpm install hadss/hmrouter第二步&#xff1a;修改全局的hvigor-config.json5(加入hm-router插件) hvigor/hvigor-config.json5 {"modelVersion": "5.0.1","dependencies": {"hadss/hmrouter-…
阅读更多...
uni-app:指引蒙层

uni-app:指引蒙层

组件说明 指引蒙层组件： 通过id标签，突出对应id中的模块； 可以自定义提示词。 点击任意位置关闭蒙层 效果展示和使用示例 切换id之后的效果： 代码实现 <template><view class="guide-mask" v-if="showMask" @click="hideMask"&g…
阅读更多...
基于Java与Go的下一代DDoS防御体系构建实战

基于Java与Go的下一代DDoS防御体系构建实战

引言：混合云时代的攻防对抗新格局 2024年某金融平台遭遇峰值2.3Tbps的IPv6混合攻击，传统WAF方案在新型AI驱动攻击面前全面失效。本文将以Java与Go为技术栈，揭示如何构建具备智能决策能力的防御系统。 一、攻击防御技术矩阵重构 1.1 混合攻击特征识别 攻击类型Java检测方案…
阅读更多...
大数据Spark（五十五）：Spark框架及特点

大数据Spark（五十五）：Spark框架及特点

文章目录 Spark框架及特点 一、Spark框架介绍 二、Spark计算框架具备以下特点 Spark框架及特点 一、Spark框架介绍 Apache Spark 是一个专为大规模数据处理而设计的快速、通用的计算引擎。最初由加州大学伯克利分校的 AMP 实验室&#xff08;Algorithms, Machines, and Pe…
阅读更多...
ubuntu 升级补丁，备份备份备份

ubuntu 升级补丁，备份备份备份

一、常规软件包更新&#xff08;安全补丁和软件升级&#xff09; 更新软件包列表 从软件源服务器获取最新的软件包信息&#xff1a; sudo apt update升级已安装的软件包 安装所有可用的更新&#xff08;安全补丁、功能更新&#xff09;&#xff1a; sudo apt upgrade处理依赖…
阅读更多...
CubeMx——串口与 printf 打印

CubeMx——串口与 printf 打印

CubeMx 配置 fputc 实现 /* USER CODE BEGIN 0 */ #include <stdio.h> /* USER CODE END 0 *//* USER CODE BEGIN 1 */ int fputc(int ch, FILE *f) {/* Place your implementation of fputc here *//* e.g. write a character to the USART */uint8_t send_data ch;HA…
阅读更多...
多线程 -- Thread类

多线程 -- Thread类

Thread 的常见构造方法 最后一个构造方法中的 ThreadGroup 线程组是 Java 中的概念&#xff0c;和系统内核中的线程组不是一个东西。我们自己创建的线程&#xff0c;默认是按照 Thread- 0 1 2 3 4...命名。但我们也可以给不同的线程&#xff0c;起不同的名字&#xff08;不同的…
阅读更多...
Java基础关键_032_反射（二）

Java基础关键_032_反射（二）

目 录 一、反射 Class 的 Method 1.反编译 String 类的方法签名 2.通过反射调用方法 3.反编译 String 类的构造方法签名 4.通过反射调用构造方法 二、类加载过程 1.装载&#xff08;Loading&#xff09; &#xff08;1&#xff09;说明 &#xff08;2&#xff09;双亲委…
阅读更多...
《数据结构：单链表》

《数据结构：单链表》

“希望就像星星&#xff0c;或许光芒微弱&#xff0c;但永不熄灭。” 博主的个人gitee&#xff1a;https://gitee.com/friend-a188881041351 一.概念与结构 链表是一种物理存储上非连续、非顺序的存储结构&#xff0c;数据元素的顺序逻辑是通过链表中的指针链接次序实现的。 单…
阅读更多...
蓝桥杯 - 中等 - 绝美宋词

蓝桥杯 - 中等 - 绝美宋词

介绍 “今宵酒醒何处&#xff0c;杨柳岸晓风残月”&#xff0c;“蓦然回首&#xff0c;那人却在灯火阑珊处”&#xff0c;“试问闲愁都几许&#xff1f;一川烟草&#xff0c;满城风絮&#xff0c;梅子黄时雨” ...... 宋词可谓是古代文学桂冠上一颗璀璨的明珠&#xff0c;本题…
阅读更多...
JDBC、excute()、DriveManager、Connection、Statement、自建JDBC工具类、占位符

JDBC、excute()、DriveManager、Connection、Statement、自建JDBC工具类、占位符

DAY19.2 Java核心基础 JDBC JDBC&#xff1a;Java database Connectivity JDBC是java程序连接各种数据库的组件 Mybatis就是基于JDBC的封装&#xff0c;是独立于数据库的管理系统&#xff0c;通用的SQL数据库存取和操作的公共接口 定义了一套标准&#xff0c;为访问 不同数…
阅读更多...
最新文章

Copyright @ 2022~2023