怒刷LeetCode的第20天（Java版）

目录

第一题

题目来源

题目内容

解决方法

方法一：回溯算法

方法二：permute方法

方法三：交换法

第二题

题目来源

题目内容

解决方法

方法一：回溯算法

方法二：递归和交换

方法三：二维列表

第三题

题目来源

题目内容

解决方法

方法一：旋转90度

方法二：使用辅助数组

方法三：先转置后反转

方法四：坐标变换

第一题

题目来源

46. 全排列 - 力扣（LeetCode）

题目内容

解决方法

方法一：回溯算法

这道题可以使用回溯算法来解决。具体思路如下：

1、创建一个结果集列表 result 来存储所有可能的全排列。
2、创建一个临时列表 tempList 来存储当前正在生成的排列。
3、创建一个布尔数组 used，用于标记数字是否已经被使用过。
4、调用回溯函数 backtrack，传入初始参数：nums 数组、used 数组、tempList 列表和 result 结果集。
5、在回溯函数中，首先判断当前排列的长度是否等于 nums 数组的长度，如果是，则说明已经完成了一种排列，将其加入结果集 result 中。
6、否则，遍历 nums 数组中的每个数字：

  • 如果该数字已经被使用过（即 used[i] 为 true），则跳过该数字，继续下一个循环。
  • 如果该数字未被使用过，则将其添加到 tempList 中，并将 used[i] 设置为 true，表示该数字已经被使用。
  • 然后进行下一层递归，即调用 backtrack 函数。
  • 在递归返回后，需要进行回溯操作，即将刚才添加的数字从 tempList 中移除，并将 used[i] 设置为 false，表示该数字未被使用。

7、回溯函数返回后，所有的排列都已经生成完毕，将结果集 result 返回。
这样，通过回溯的递归过程，可以生成所有可能的全排列。

import java.util.ArrayList;
import java.util.List;class Solution {public List<List<Integer>> permute(int[] nums) {List<List<Integer>> result = new ArrayList<>();List<Integer> tempList = new ArrayList<>();boolean[] used = new boolean[nums.length];backtrack(nums, used, tempList, result);return result;}private void backtrack(int[] nums, boolean[] used, List<Integer> tempList, List<List<Integer>> result) {if (tempList.size() == nums.length) {result.add(new ArrayList<>(tempList));return;}for (int i = 0; i < nums.length; i++) {if (used[i]) continue; // 如果该数已经被使用过，则跳过tempList.add(nums[i]);used[i] = true;backtrack(nums, used, tempList, result);tempList.remove(tempList.size() - 1);used[i] = false;}}
}

复杂度分析：

  • 时间复杂度： 在回溯算法中，我们需要生成所有可能的全排列。对于每个位置，我们有N种选择。因此，在最坏的情况下，需要进行N次选择操作。对于每个选择，递归地搜索剩下的位置。因此，总的时间复杂度为O(N!)，其中N是nums数组的长度。
  • 空间复杂度： 在回溯算法中，我们使用了一个临时列表 tempList 和一个布尔数组 used。在每一层递归调用时，tempList 的长度最多为N，used 数组也会占用N个空间。递归调用栈的深度最大为N。因此，总的空间复杂度为O(N)。

综上所述，该解法的时间复杂度为O(N!)，空间复杂度为O(N)。

LeetCode运行结果：

方法二：permute方法

除了回溯算法外，还可以使用Java的库函数Collections中的permute方法来生成全排列。具体步骤如下：

  • 将给定的数组转换为List类型。
  • 使用Collections类中的permute方法生成所有可能的全排列。
  • 将结果转换为List<List<Integer>>类型的形式。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;class Solution {public List<List<Integer>> permute(int[] nums) {List<List<Integer>> result = new ArrayList<>();// 转换为List类型List<Integer> list = new ArrayList<>();for (int num : nums) {list.add(num);}// 使用库函数生成全排列permuteHelper(list, 0, result);return result;}private void permuteHelper(List<Integer> list, int start, List<List<Integer>> result) {if (start == list.size()) {result.add(new ArrayList<>(list));} else {for (int i = start; i < list.size(); i++) {// 交换元素Collections.swap(list, start, i);// 继续生成后面的排列permuteHelper(list, start + 1, result);// 恢复原始顺序Collections.swap(list, start, i);}}}
}

复杂度分析：

  • 时间复杂度：在这种解法中，我们使用了Collections.permute函数来生成全排列。该函数的时间复杂度是O(N!)，其中N是数组的长度。
  • 空间复杂度：在这个解法中，我们创建了一个二维列表 result 来存储所有可能的全排列。这个二维列表的空间复杂度是O(N!)，其中N是数组的长度。同时，也需要考虑到递归调用栈的空间消耗，因为在permuteHelper函数中进行了递归调用。递归调用的深度最大为N，所以递归调用栈的空间复杂度也是O(N)。

综上所述，使用库函数Collections.permute的解法的时间复杂度为O(N!)，空间复杂度为O(N!)。

LeetCode运行结果：

方法三：交换法

除了回溯算法和库函数Collections，还可以使用交换法来生成全排列。

交换法的思路是：

  1. 从数组的第一个位置开始，依次将每个位置的元素与后面的元素交换，得到不同的排列。
  2. 对于每个位置，将其与后面的元素进行交换，然后递归地处理剩下的位置。
  3. 当处理到最后一个位置时，将当前排列加入结果中。
import java.util.ArrayList;
import java.util.List;class Solution {public List<List<Integer>> permute(int[] nums) {List<List<Integer>> result = new ArrayList<>();// 转换为List类型List<Integer> list = new ArrayList<>();for (int num : nums) {list.add(num);}permuteHelper(list, 0, result);return result;}private void permuteHelper(List<Integer> list, int start, List<List<Integer>> result) {if (start == list.size() - 1) {result.add(new ArrayList<>(list));} else {for (int i = start; i < list.size(); i++) {Collections.swap(list, start, i); // 交换元素permuteHelper(list, start + 1, result); // 递归处理下一个位置Collections.swap(list, start, i); // 恢复原始顺序}}}
}

复杂度分析：

  • 时间复杂度：在这种解法中，我们使用了递归来生成全排列。每次递归都会将当前位置的元素与后面的元素进行交换，所以总共需要进行N次交换操作。对于每次交换操作，有N-1个选择，因此总的时间复杂度为O(N * N!)。
  • 空间复杂度：在这个解法中，我们创建了一个二维列表 result 来存储所有可能的全排列。这个二维列表的空间复杂度是O(N!)，其中N是数组的长度。同时，也需要考虑到递归调用栈的空间消耗，因为在permuteHelper函数中进行了递归调用。递归调用的深度最大为N，所以递归调用栈的空间复杂度也是O(N)。

综上所述，使用交换法的解法的时间复杂度为O(N * N!)，空间复杂度为O(N!)。

LeetCode运行结果：

第二题

题目来源

47. 全排列 II - 力扣（LeetCode）

题目内容

解决方法

方法一：回溯算法

可以使用回溯算法来解决这个问题。回溯算法通过遍历所有可能的解空间来找到问题的解。

具体步骤如下：

  1. 首先将给定的序列 nums 进行排序，以便于后续处理。

  2. 创建一个空列表 result 来存储所有的全排列。

  3. 创建一个空列表 path 来存储当前正在构建的排列。

  4. 创建一个与 nums 长度相等的布尔数组 used，用于记录每个元素是否已经被使用过。

  5. 调用回溯函数 backtrack(0) 开始生成全排列。

  6. 在回溯函数 backtrack 中，首先判断如果 path 的长度等于 nums 的长度，则将 path 加入到 result 中，并返回。

  7. 否则，遍历 nums 数组，对于每个元素 nums[i]，进行以下操作：

    • 如果当前元素 nums[i] 已经被使用过（used[i] = true），则跳过该元素。

    • 如果当前元素 nums[i] 与前一个元素相同，并且前一个元素还没有被使用过（used[i-1] = false），则跳过该元素。这是为了避免生成重复的排列。

    • 将当前元素 nums[i] 添加到 path 中，并将 used[i] 设置为 true，表示已经使用过。

    • 递归调用 backtrack(i+1) 继续生成下一个位置的元素。

    • 回溯：将当前元素从 path 中移除，并将 used[i] 设置为 false，表示回溯到上一层。

  8. 最后返回 result。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Solution {public List<List<Integer>> permuteUnique(int[] nums) {List<List<Integer>> result = new ArrayList<>();List<Integer> path = new ArrayList<>();boolean[] used = new boolean[nums.length];Arrays.sort(nums); // 对nums进行排序backtrack(nums, used, path, result);return result;}private void backtrack(int[] nums, boolean[] used, List<Integer> path, List<List<Integer>> result) {if (path.size() == nums.length) {result.add(new ArrayList<>(path));return;}for (int i = 0; i < nums.length; i++) {if (used[i]) {continue;}if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {continue;}path.add(nums[i]);used[i] = true;backtrack(nums, used, path, result);path.remove(path.size() - 1);used[i] = false;}}
}

复杂度分析：

对于给定长度为 n 的序列 nums，我们来分析一下算法的时间复杂度和空间复杂度。

时间复杂度：

  • 排序 nums 数组的时间复杂度为 O(nlogn)。
  • 回溯算法的时间复杂度为 O(n!)，其中 n! 表示全排列的个数。在最坏情况下，所有元素都不相同，共有 n! 个全排列。
  • 综上所述，算法的总时间复杂度为 O(nlogn + n!)。

空间复杂度：

  • 算法使用了额外的空间来存储结果集和回溯过程中的临时路径，即列表 result 和 path，它们的空间复杂度为 O(n!)。
  • used 数组的空间复杂度为 O(n)，用于记录每个元素是否已经被使用过。
  • 综上所述，算法的总空间复杂度为 O(n!)。

需要注意的是，由于全排列的个数可以很大（n!），因此在实际应用中，当 n 较大时，算法可能会耗费较多的时间和空间资源。

LeetCode运行结果：

方法二：递归和交换

除了回溯算法，我们还可以使用其他方法来解决这个问题。

一种常用的方法是使用递归和交换元素的方式来生成全排列。具体步骤如下：

  1. 首先创建一个空列表 result 来存储所有的全排列。

  2. 调用递归函数 backtrack(nums, 0, result) 开始生成全排列。

  3. 在递归函数 backtrack 中，首先判断如果当前位置 index 等于 nums 数组的长度，则将当前排列加入到 result 中，并返回。

  4. 否则，遍历从 index 到 nums 数组末尾的所有位置，对于每个位置 i，进行以下操作：

    • 如果当前位置 index 和位置 i 的元素相同，则跳过该位置，以避免生成重复的排列。

    • 将当前位置 index 和位置 i 的元素交换。

    • 递归调用 backtrack(nums, index + 1, result) 继续生成下一个位置的元素。

    • 回溯：将当前位置 index 和位置 i 的元素交换回来。

  5. 最后返回 result。

import java.util.ArrayList;
import java.util.List;public class Solution {public List<List<Integer>> permuteUnique(int[] nums) {List<List<Integer>> result = new ArrayList<>();backtrack(nums, 0, result);return result;}private void backtrack(int[] nums, int index, List<List<Integer>> result) {if (index == nums.length) {List<Integer> permutation = new ArrayList<>();for (int num : nums) {permutation.add(num);}result.add(permutation);return;}for (int i = index; i < nums.length; i++) {if (isDuplicate(nums, index, i)) {continue;}swap(nums, index, i);backtrack(nums, index + 1, result);swap(nums, index, i); // 回溯}}private boolean isDuplicate(int[] nums, int start, int end) {for (int i = start; i < end; i++) {if (nums[i] == nums[end]) {return true;}}return false;}private void swap(int[] nums, int i, int j) {int temp = nums[i];nums[i] = nums[j];nums[j] = temp;}
}

这样就可以通过调用 permuteUnique 方法来获取给定序列的所有不重复全排列。这种方法在实现上更加简洁，但是在效率上可能略逊于回溯算法。 

复杂度分析：

时间复杂度：

  • 在递归函数中，对每个位置都进行了不重复全排列的探索，时间复杂度为 O(n!)，其中 n 表示数组 nums 的长度。
  • 对于每个位置，需要遍历从当前位置到数组末尾的所有元素，时间复杂度为 O(n)，其中 n 表示数组 nums 的长度。
  • 综上所述，算法的总时间复杂度为 O(n * n!)。

空间复杂度：

  • 使用了额外的空间来存储结果集和递归过程中的临时路径，即列表 result 和递归调用栈的开销。
  • 结果集 result 最多包含 n! 个全排列，因此空间复杂度为 O(n!)。
  • 递归调用栈的最大深度为 n，因此空间复杂度为 O(n)。
  • 综上所述，算法的总空间复杂度为 O(n + n!)。

需要注意的是，全排列的个数可以很大（n!），因此在实际应用中，当 n 较大时，算法可能会耗费较多的时间和空间资源。

LeetCode运行结果：

方法三：二维列表

除了回溯算法和递归交换元素，我们还可以使用其他方法来生成全排列。以下是另一种常用的方法：

  1. 首先，将数组 nums 转换为一个 ArrayList 来方便后续操作。

  2. 创建一个空的二维列表 result 来存储全排列。

  3. 调用递归函数 permuteUniqueHelper(ArrayList<Integer> nums, int start, List<List<Integer>> result) 来生成全排列。

  4. 在递归函数 permuteUniqueHelper 中，首先判断如果当前位置 start 等于 nums 列表的长度，则将当前排列加入到 result 中，并返回。

  5. 否则，遍历从 start 到 nums 列表末尾的所有位置，对于每个位置 i，进行以下操作：

    • 如果当前位置 start 和位置 i 的元素相同，则跳过该位置，以避免生成重复的排列。

    • 交换当前位置 start 和位置 i 的元素。

    • 将当前位置 start 的元素固定，继续递归调用 permuteUniqueHelper(nums, start + 1, result) 来生成下一个位置的元素。

    • 回溯：恢复位置 start 和位置 i 的元素的原始顺序。

  6. 最后返回 result。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;public class Solution {public List<List<Integer>> permuteUnique(int[] nums) {List<List<Integer>> result = new ArrayList<>();ArrayList<Integer> numsList = new ArrayList<>();for (int num : nums) {numsList.add(num);}permuteUniqueHelper(numsList, 0, result);return result;}private void permuteUniqueHelper(ArrayList<Integer> nums, int start, List<List<Integer>> result) {if (start == nums.size()) {result.add(new ArrayList<>(nums));return;}for (int i = start; i < nums.size(); i++) {if (isDuplicate(nums, start, i)) {continue;}// 交换位置 start 和位置 i 的元素swap(nums, start, i);// 固定位置 start 的元素，递归生成下一个位置的元素permuteUniqueHelper(nums, start + 1, result);// 恢复位置 start 和位置 i 的元素的原始顺序，进行回溯swap(nums, start, i);}}private boolean isDuplicate(ArrayList<Integer> nums, int start, int end) {for (int i = start; i < end; i++) {if (nums.get(i).equals(nums.get(end))) {return true;}}return false;}private void swap(ArrayList<Integer> nums, int i, int j) {Integer temp = nums.get(i);nums.set(i, nums.get(j));nums.set(j, temp);}
}

这种方法与之前的方法相比稍微简洁一些，并且在效率上也具有一定优势。同样地，需要注意全排列的个数可能很大，因此在处理较大规模的输入时仍然需要谨慎考虑算法的时间和空间复杂度。 

复杂度分析：

时间复杂度：

  • 对于每个位置，我们需要遍历从该位置到数组末尾的所有元素，所以在递归函数中，我们有一个循环，其迭代次数是 n - start，其中 n 是数组的长度。
  • 在每个位置上，我们需要判断当前元素是否与之前固定的元素重复，这涉及到遍历之前的元素集合。因此，在每个位置上，我们还有一个内层循环，其迭代次数不会超过当前位置的索引。
  • 综上所述，在递归函数中，总的时间复杂度为 O(n!)。这是因为对于每个排列，我们需要进行 n 次交换操作，所以时间复杂度是阶乘级别的。

空间复杂度：

  • 我们使用了一个二维列表 result 来存储所有的全排列结果，所以需要额外的空间来存储这些结果。这些结果的数量是 n!，所以空间复杂度是 O(n!)。
  • 另外，我们使用了一个 ArrayList numsList 来将传入的数组转换为列表，所以需要额外的 O(n) 的空间来存储该列表。

综上所述，该方法的时间复杂度是 O(n!)，空间复杂度是 O(n!)，其中 n 是数组的长度。需要注意的是，由于全排列的数量是非常大的，因此在处理较大规模的输入时，可能会受到时间和空间复杂度的限制。

LeetCode运行结果：

第三题

题目来源

48. 旋转图像 - 力扣（LeetCode）

题目内容

解决方法

方法一：旋转90度

题目要求将给定的二维矩阵顺时针旋转90度，并且需要在原地修改输入的矩阵。

解题思路：

  1. 首先，将矩阵沿副对角线翻转。可以通过使用两个循环，分别遍历矩阵的上半部分，交换对应位置的元素，实现翻转。
  2. 然后，将矩阵沿水平中线翻转。同样使用两个循环，分别遍历矩阵的上半部分和下半部分，交换对应位置的元素，实现翻转。

通过以上步骤，就可以将矩阵顺时针旋转90度。注意，这里的翻转操作是在原矩阵上进行的，因此不需要使用额外的空间。

class Solution {
public void rotate(int[][] matrix) {int n = matrix.length;// 先将矩阵沿副对角线翻转for (int i = 0; i < n; i++) {for (int j = 0; j < n - i; j++) {int temp = matrix[i][j];matrix[i][j] = matrix[n - j - 1][n - i - 1];matrix[n - j - 1][n - i - 1] = temp;}}// 再将矩阵沿水平中线翻转for (int i = 0; i < n / 2; i++) {for (int j = 0; j < n; j++) {int temp = matrix[i][j];matrix[i][j] = matrix[n - i - 1][j];matrix[n - i - 1][j] = temp;}}
}}

复杂度分析：

对于给定的 n × n 矩阵，我们需要沿副对角线翻转矩阵并沿水平中线翻转矩阵，来完成顺时针旋转90度的操作。

时间复杂度分析：

  • 沿副对角线翻转的过程，需要遍历矩阵的上半部分元素，共有 n(n+1)/2 个元素。因此，时间复杂度为 O(n^2)。
  • 沿水平中线翻转的过程，需要遍历矩阵的上半部分和下半部分元素，共有 n(n/2) 个元素。因此，时间复杂度同样为 O(n^2)。 总体时间复杂度为 O(n^2)。

空间复杂度分析：

  • 原地修改输入的矩阵，不需要使用额外的空间。因此，空间复杂度为 O(1)。

综上所述，该算法的时间复杂度为 O(n^2)，空间复杂度为 O(1)。

LeetCode运行结果：

方法二：使用辅助数组

该方法通过创建一个辅助数组来存储旋转后的矩阵元素，然后将辅助数组中的元素重新赋值给原矩阵。

class Solution {
public void rotate(int[][] matrix) {int n = matrix.length;int[][] temp = new int[n][n];// 将矩阵元素赋值给辅助数组for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {temp[i][j] = matrix[i][j];}}// 将辅助数组中的元素按规则赋值给原矩阵for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {matrix[j][n - i - 1] = temp[i][j];}}
}}

复杂度分析：

时间复杂度分析：

  • 创建辅助数组需要遍历原矩阵的所有元素，时间复杂度为 O(n^2)。
  • 将辅助数组的元素重新赋值给原矩阵也需要遍历所有元素，时间复杂度为 O(n^2)。 总体时间复杂度为 O(n^2)。

空间复杂度分析：

  • 需要创建一个与原矩阵大小相同的辅助数组，因此空间复杂度为 O(n^2)。

LeetCode运行结果：

方法三：先转置后反转

该方法先将矩阵进行转置操作（行列互换），然后再对每一行进行反转操作。

class Solution {
public void rotate(int[][] matrix) {int n = matrix.length;// 转置矩阵for (int i = 0; i < n; i++) {for (int j = i; j < n; j++) {int temp = matrix[i][j];matrix[i][j] = matrix[j][i];matrix[j][i] = temp;}}// 反转每一行for (int i = 0; i < n; i++) {for (int j = 0; j < n / 2; j++) {int temp = matrix[i][j];matrix[i][j] = matrix[i][n - j - 1];matrix[i][n - j - 1] = temp;}}
}}

复杂度分析：

时间复杂度分析：

  • 转置矩阵的过程需要遍历矩阵中的上三角部分元素，共有 n(n+1)/2 个元素，因此时间复杂度为 O(n^2)。
  • 反转每一行的过程需要遍历矩阵中的每一行的前一半元素，共有 n(n/2) 个元素，因此时间复杂度同样为 O(n^2)。 总体时间复杂度为 O(n^2)。

空间复杂度分析：

  • 原地修改输入的矩阵，不需要使用额外的空间。因此，空间复杂度为 O(1)。

LeetCode运行结果：

方法四：坐标变换

还有一种基于坐标变换的方法可以实现矩阵的旋转。

该方法的思想是通过找到旋转前后对应位置的关系，直接将旋转后的元素赋值给旋转前的位置。这种方法通过循环遍历矩阵中的四个角落的元素，逐步交换它们的值，实现矩阵的旋转。

class Solution {
public void rotate(int[][] matrix) {int n = matrix.length;// 对每个元素进行旋转for (int i = 0; i < n / 2; i++) {for (int j = i; j < n - i - 1; j++) {int temp = matrix[i][j];matrix[i][j] = matrix[n - j - 1][i];matrix[n - j - 1][i] = matrix[n - i - 1][n - j - 1];matrix[n - i - 1][n - j - 1] = matrix[j][n - i - 1];matrix[j][n - i - 1] = temp;}}
}}

复杂度分析：

时间复杂度分析：

  • 循环嵌套的两个 for 循环遍历了矩阵的四分之一，因此时间复杂度为 O(n^2/4)，即 O(n^2)。
  • 在每个内部循环中，交换四个元素的值需要常数时间。 总体时间复杂度为 O(n^2)。

空间复杂度分析：

  • 该方法在原矩阵上进行操作，不需要额外的辅助数组，因此空间复杂度为 O(1)。

综上所述，该方法的时间复杂度为 O(n^2)，空间复杂度为 O(1)。这是一种高效的解决方案。

LeetCode运行结果：

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

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

相关文章

Vue城市选择器示例（省市区三级）

Vue城市选择器示例（省市区三级）

Vue城市选择器&#xff08;省市区&#xff09; 读者可以参考下面的省市区三级联动代码思路&#xff0c;切记要仔细研究透彻&#xff0c;学习交流才是我们的本意&#xff0c;而非一成不变。切记切记&#xff01; 最近又重读苏子的词&#xff0c;颇为感慨&#xff0c;愿与诸君共…
阅读更多...
数学建模Matlab之评价类方法

数学建模Matlab之评价类方法

大部分方法来自于http://t.csdnimg.cn/P5zOD 层次分析法 层次分析法&#xff08;Analytic Hierarchy Process, AHP&#xff09;是一种结构决策的定量方法&#xff0c;主要用于处理复杂问题的决策分析。它将问题分解为目标、准则和方案等不同层次&#xff0c;通过成对比较和计算…
阅读更多...
WebAPI文档与自动化测试

WebAPI文档与自动化测试

本篇介绍框架的WebAPI文档与自动化测试 1、控制器&#xff0c;项目属性里需要勾选输出Xml文档选项&#xff1a; 然后&#xff0c;针对方法写好注释即可&#xff0c;示例&#xff1a; /// <summary>/// 微服务测试/// </summary>public class MSController : Cont…
阅读更多...
LongLoRA:不需要大量计算资源的情况下增强了预训练语言模型的上下文能力

LongLoRA:不需要大量计算资源的情况下增强了预训练语言模型的上下文能力

麻省理工学院和香港中文大学推出了LongLoRA&#xff0c;这是一种革命性的微调方法&#xff0c;可以在不需要大量计算资源的情况下提高大量预训练语言模型的上下文能力。 LongLoRA是一种新方法&#xff0c;它使改进大型语言计算机程序变得更容易&#xff0c;成本更低。训练LLM往…
阅读更多...
使用GDIView排查GDI对象泄漏导致的程序UI界面绘制异常问题

使用GDIView排查GDI对象泄漏导致的程序UI界面绘制异常问题

目录 1、问题说明 2、初步分析 3、查看任务管理器&#xff0c;并使用GDIView工具分析 4、GDIView可能对Win10兼容性不好&#xff0c;显示的GDI对象个数不太准确 5、采用历史版本比对法&#xff0c;确定初次出现问题的时间点&#xff0c;并查看前一天的代码修改记录 6、将…
阅读更多...
postman 自动升级后恢复collection数据

postman 自动升级后恢复collection数据

一、今天postman 自动升级了&#xff0c;导致一定要注册账号才能使用&#xff0c;登录账号后&#xff0c;发现之前的数据全部没有了。 找到目录&#xff1a;C:\Users\{{用户名}}\AppData\Roaming\Postman重新导入即可。 二、关闭自动更新&#xff1a;修改host&#xff0c;C:\W…
阅读更多...
【数据结构】【C++】封装哈希表模拟实现unordered_map和unordered_set容器

【数据结构】【C++】封装哈希表模拟实现unordered_map和unordered_set容器

【数据结构】&&【C】封装哈希表模拟实现unordered_map和unordered_set容器 一.哈希表的完成二.改造哈希表(泛型适配)三.封装unordered_map和unordered_set的接口四.实现哈希表迭代器(泛型适配)五.封装unordered_map和unordered_set的迭代器六.解决key不能修改问题七.实…
阅读更多...
uniapp ui安装 阿里图标库使用 报错 Assignment to constant variable.

uniapp ui安装 阿里图标库使用 报错 Assignment to constant variable.

安装 ui uni-app官网 (dcloud.net.cn) &#xff08;一&#xff09;安装 pages.js配置 安装 sassnpm i sass -D 或 yarn add sass -D 安装 sass-loader npm i sass-loader10.1.1 -D 或 yarn add sass-loader10.1.1 -D安装 uni-uinpm i dcloudio/uni-ui 或 yarn a…
阅读更多...
SpringMVC-拦截器

SpringMVC-拦截器

过滤器实现Filter接口&#xff0c;是处理Servlet请求的&#xff1b;而拦截器实现HanderInception接口&#xff0c;处理Spring-mvc请求的。 一、拦截器的基本使用 方式一&#xff1a; 方式二&#xff1a; 在经过步骤一直接可以到4 注意&#xff1a;ProjectInterceptor类 最好…
阅读更多...
YOLOV8-DET转ONNX和RKNN

YOLOV8-DET转ONNX和RKNN

目录 1. 前言 2.环境配置 (1) RK3588开发板Python环境 (2) PC转onnx和rknn的环境 3.PT模型转onnx 4. ONNX模型转RKNN 6.测试结果 1. 前言 yolov8就不介绍了&#xff0c;详细的请见YOLOV8详细对比&#xff0c;本文章注重实际的使用&#xff0c;从拿到yolov8的pt检测模型&…
阅读更多...
ping通但浏览器访问不了

ping通但浏览器访问不了

ipconfig /renew ipconfig /flushdnshttps://mbd.baidu.com/newspage/data/dtlandingsuper?niddt_3086405504299374796
阅读更多...
Shiro高级及SaaS-HRM的认证授权

Shiro高级及SaaS-HRM的认证授权

Shiro在SpringBoot工程的应用 Apache Shiro是一个功能强大、灵活的&#xff0c;开源的安全框架。它可以干净利落地处理身份验证、授权、企业会话管理和加密。越来越多的企业使用Shiro作为项目的安全框架&#xff0c;保证项目的平稳运行。 在之前的讲解中只是单独的使用shiro&…
阅读更多...
SPSS探索性分析

SPSS探索性分析

前言&#xff1a; 本专栏参考教材为《SPSS22.0从入门到精通》&#xff0c;由于软件版本原因&#xff0c;部分内容有所改变&#xff0c;为适应软件版本的变化&#xff0c;特此创作此专栏便于大家学习。本专栏使用软件为&#xff1a;SPSS25.0 本专栏所有的数据文件可在个人主页—…
阅读更多...
ElementUI之动态树+数据表格+分页

ElementUI之动态树+数据表格+分页

目录 前言 一.ElementUI之动态树 1.前端模板演示 2.数据绑定 2.1 通过链接获取后台数据 2.2 对链接进行绑定 2.3添加动态路由 2.4 配置路由 3.效果演示 二.数据表格动态分页 1.前端模板 2.通过JS交互获取后端数据 3 效果演示 前言 Element UI 是一个基于 Vue.js 的开…
阅读更多...
1.4.C++项目：仿mudou库实现并发服务器之buffer模块的设计

1.4.C++项目：仿mudou库实现并发服务器之buffer模块的设计

一、buffer模块&#xff1a; 缓冲区模块 Buffer模块是一个缓冲区模块&#xff0c;用于实现通信中用户态的接收缓冲区和发送缓冲区功能。 二、提供的功能 存储数据&#xff0c;取出数据 三、实现思想 1.实现换出去得有一块内存空间&#xff0c;采用vector ,vector底层是一个…
阅读更多...
华为智能企业上网行为管理安全解决方案（1）

华为智能企业上网行为管理安全解决方案（1）

华为智能企业上网行为管理安全解决方案&#xff08;1&#xff09; 课程地址方案背景需求分析企业上网行为概述企业上网行为安全风险分析企业上网行为管理需求分析 方案设计组网架构设备选型设备简介行为管理要点分析方案功能概述 课程地址 本方案相关课程资源已在华为O3社区发…
阅读更多...
8个居家兼职，帮助自己在家搞副业

8个居家兼职，帮助自己在家搞副业

越来越多的人开始追求居家工作的机会&#xff0c;无论是为了获得更多收入以改善生活质量&#xff0c;还是为了更好地平衡工作和家庭的关系&#xff0c;居家兼职已成为一种趋势。而在家中从事副业不仅能够为我们带来额外的收入&#xff0c;更重要的是&#xff0c;它可以让我们在…
阅读更多...
Vue 实现表单的增删改查功能及表单的验证

Vue 实现表单的增删改查功能及表单的验证

前言&#xff1a; 上一篇我们已经将前端表单的数据和后端的数据交互了&#xff0c;今天我们就继续开发功能来实现表单的增删改查功能及表单的验证 一&#xff0c;表单的增删改查功能 新增 去官网找模版&#xff1a; 1.1添加新增按钮&#xff1a; 1.2添加新增弹窗点击事件&am…
阅读更多...
二叉树MFC实现

二叉树MFC实现

设有一颗二叉树如下&#xff1b; 这似乎是一颗经常用作示例的二叉树&#xff1b; 对树进行遍历的结果是&#xff0c; 先序为&#xff1a;3、2、2、3、8、6、5、4&#xff0c; 中序为&#xff1a;2、2、3、3、4、5、6、8&#xff0c; 后序为2、3、2、4、5、6、8、3&#xff1b…
阅读更多...
基于Vue和Element UI实现前后端分离和交互

基于Vue和Element UI实现前后端分离和交互

目录 前言 一、Element UI简介 1.Element UI是什么 2.Element UI的特点 二、项目搭建 1.创建一个SPA项目 2.安装 Element-UI 3.导入组件 4.创建登陆注册界面 登录组件---Login.vue 注册组件---Register.vue 定义组件与路由的对应关系 效果演示&#xff1a; 三、前…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发