怒刷LeetCode的第14天（Java版）

已于 2023-09-23 21:43:32 修改
阅读量195 收藏 2
点赞数 3
分类专栏： LeetCode算法 文章标签： leetcode 算法 职场和发展
于 2023-09-23 21:42:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74293254/article/details/133217256
版权

目录

第一题

题目来源

题目内容

解决方法

方法一：动态规划

方法二：栈

方法三：双指针

第二题

题目来源

题目内容

解决方法

方法一：二分查找

方法二：线性扫描

方法三：递归

第三题

题目来源

题目内容

解决方法

方法一：二分查找

方法二：线性扫描

方法三：双指针

第一题

题目来源

32. 最长有效括号 - 力扣（LeetCode）

题目内容

解决方法

方法一：动态规划

  1. 创建一个长度为 n 的数组 dp，用于保存以当前字符结尾的最长有效括号子串的长度。
  2. 初始化 dp 数组的所有元素为 0。
  3. 遍历字符串 s 的每个字符：
    • 如果当前字符是 (，则直接跳过。
    • 如果当前字符是 )，则判断前一个字符是否是 (：
      • 如果前一个字符是 (，则更新 dp[i] = dp[i-2] + 2，表示以当前字符结尾的最长有效括号子串长度为前一个字符结尾的最长有效括号子串长度加上当前的两个括号。
      • 如果前一个字符是 )，则判断前一个字符结尾的最长有效括号子串之前的字符是否是 (，即判断 i-dp[i-1]-1 位置的字符是否是 (：
        • 如果是 (，则更新 dp[i] = dp[i-1] + dp[i-dp[i-1]-2] + 2，表示以当前字符结尾的最长有效括号子串长度为前一个字符结尾的最长有效括号子串长度加上前一个字符结尾的最长有效括号子串之前的最长有效括号子串长度加上当前的两个括号。
  4. 遍历完整个字符串后，找出 dp 数组中的最大值，即为最长有效括号子串的长度。
public class Solution {
    public int longestValidParentheses(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        
        int n = s.length();
        int[] dp = new int[n];
        int maxLen = 0;
        
        for (int i = 1; i < n; i++) {
            if (s.charAt(i) == ')') {
                if (s.charAt(i - 1) == '(') {
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
                } else if (i - dp[i - 1] > 0 && s.charAt(i - dp[i - 1] - 1) == '(') {
                    dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                maxLen = Math.max(maxLen, dp[i]);
            }
        }
        
        return maxLen;
    }
}

复杂度分析：

时间复杂度：

  • 遍历字符串 s 的每个字符需要 O(n) 的时间。
  • 在每个字符上，我们都进行了常数次的比较和更新操作。
  • 因此，总体上，时间复杂度为 O(n)。

空间复杂度：

  • 我们使用了一个长度为 n 的数组 dp 来保存以当前字符结尾的最长有效括号子串的长度。
  • 因此，空间复杂度为 O(n)。

综合起来，该解法的时间复杂度为 O(n)，空间复杂度为 O(n)。

注意：对于这个特定的问题，在给定的限制条件下（0 <= s.length <= 3 * 10^4），这个解法是高效且可行的。

LeetCode运行结果：

方法二：栈

该方法的思路如下：

  • 首先，我们使用一个栈来保存括号的索引位置。
  • 初始化栈，将一个特殊的值 -1 放入栈中。
  • 遍历字符串 s 的每个字符：
    • 如果遇到左括号 (，将其索引位置压入栈中。
    • 如果遇到右括号 )，弹出栈顶元素，表示当前右括号匹配了一个左括号。
      • 如果栈为空，将当前右括号的索引位置压入栈中，作为一个新的起点。
      • 如果栈不为空，计算当前有效括号子串的长度，更新最大长度。
  • 最后，返回最大长度即可。
import java.util.Stack;

public class Solution {
    public int longestValidParentheses(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        
        int maxLen = 0;
        Stack<Integer> stack = new Stack<>();
        stack.push(-1);
        
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            
            if (c == '(') {
                stack.push(i);
            } else {
                stack.pop();
                
                if (stack.isEmpty()) {
                    stack.push(i);
                } else {
                    maxLen = Math.max(maxLen, i - stack.peek());
                }
            }
        }
        
        return maxLen;
    }
}

复杂度分析：

时间复杂度：

  • 遍历字符串 s 的每个字符需要 O(n) 的时间。
  • 在每个字符上，我们进行了常数次的栈操作（压栈和弹栈）。
  • 因此，总体上，时间复杂度为 O(n)。

空间复杂度：

  • 我们使用了一个栈来保存括号的索引位置。
  • 在最坏情况下，当所有字符都是左括号时，栈的大小为 n。
  • 因此，空间复杂度为 O(n)。

综合起来，该方法的时间复杂度为 O(n)，空间复杂度为 O(n)。

LeetCode运行结果：

方法三：双指针

除了动态规划和栈，还有一种双指针的方法来解决最长有效括号问题。

这种方法的思路如下：

  • 从左到右遍历字符串，统计左右括号的数量。
  • 如果左右括号数量相等，则更新最大长度。
  • 如果右括号数量大于左括号数量，则重置左右括号数量为0。
  • 然后从右到左再进行一次相同的操作。
public class Solution {
    public int longestValidParentheses(String s) {
        if (s == null || s.length() == 0) {
            return 0;
        }
        
        int left = 0; // 左括号数量
        int right = 0; // 右括号数量
        int maxLen = 0; // 最大长度
        
        // 从左到右遍历
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '(') {
                left++;
            } else {
                right++;
            }
            
            // 如果左括号数量等于右括号数量，则计算当前有效括号子串的长度
            if (left == right) {
                maxLen = Math.max(maxLen, right * 2);
            } else if (right > left) { // 右括号数量大于左括号数量，重置左右括号数量为0
                left = 0;
                right = 0;
            }
        }
        
        left = 0;
        right = 0;
        
        // 从右到左遍历
        for (int i = s.length() - 1; i >= 0; i--) {
            char c = s.charAt(i);
            if (c == ')') {
                right++;
            } else {
                left++;
            }
            
            // 如果左括号数量等于右括号数量，则计算当前有效括号子串的长度
            if (left == right) {
                maxLen = Math.max(maxLen, left * 2);
            } else if (left > right) { // 左括号数量大于右括号数量，重置左右括号数量为0
                left = 0;
                right = 0;
            }
        }
        
        return maxLen;
    }
}

复杂度分析：

时间复杂度：

  • 遍历字符串 s 的每个字符需要 O(n) 的时间。
  • 在第一次从左到右遍历中，我们进行了常数次的操作，不会产生额外的时间复杂度。
  • 在第二次从右到左遍历中，同样也进行了常数次的操作。
  • 因此，总体上，时间复杂度为 O(n)。

空间复杂度：

  • 我们只使用了常数个变量来保存左右括号的数量和最大长度，没有使用额外的数据结构。
  • 因此，空间复杂度为 O(1)。

综合起来，该方法的时间复杂度为 O(n)，空间复杂度为 O(1)。

LeetCode运行结果：

第二题

题目来源

33. 搜索旋转排序数组 - 力扣（LeetCode）

题目内容

解决方法

方法一：二分查找

使用二分查找的思想，通过判断左右半边哪一边是有序的来决定向哪边继续查找。具体步骤如下：

  1. 初始化左指针 left 为数组的第一个元素的索引，右指针 right 为数组最后一个元素的索引。
  2. 在每次循环中，计算中间元素的索引 mid。
  3. 如果中间元素等于目标值，则返回 mid。
  4. 判断左半边是否有序（即 nums[left] <= nums[mid]）：
    • 如果目标值在左半边的有序范围内，则将右指针 right 移动到 mid - 1，继续在左半边查找。
    • 否则，将左指针 left 移动到 mid + 1，继续在右半边查找。
  5. 如果左半边不是有序的，则右半边一定是有序的。判断目标值是否在右半边的有序范围内：
    • 如果是，则将左指针 left 移动到 mid + 1，继续在右半边查找。
    • 否则，将右指针 right 移动到 mid - 1，继续在左半边查找。
  6. 如果循环结束仍未找到目标值，则返回 -1。
public class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        int left = 0;
        int right = nums.length - 1;
        
        while (left <= right) {
            int mid = left + (right - left) / 2;
            
            if (nums[mid] == target) {
                return mid;
            }
            
            if (nums[left] <= nums[mid]) { // 左半边有序
                if (target >= nums[left] && target < nums[mid]) {
                    right = mid - 1;
                } else {
                    left = mid + 1;
                }
            } else { // 右半边有序
                if (target > nums[mid] && target <= nums[right]) {
                    left = mid + 1;
                } else {
                    right = mid - 1;
                }
            }
        }
        
        return -1;
    }
}

复杂度分析：

  • 该算法的时间复杂度为O(log n)，其中n是数组的长度。在每次循环中，都将搜索范围缩小一半，所以总共最多需要进行log n次循环。因此，算法的时间复杂度为O(log n)。
  • 空间复杂度为O(1)，因为算法只使用了有限的额外空间来存储指针和常量。

总结起来，该算法具有较低的时间复杂度和空间复杂度，能够高效地解决搜索旋转排序数组的问题。

LeetCode运行结果：

方法二：线性扫描

除了二分查找的方法，还可以使用线性扫描的方法来搜索旋转排序数组。

该算法从数组的第一个元素开始，依次遍历数组中的每个元素，如果找到目标值，则返回其索引；如果遍历结束仍未找到目标值，则返回-1。

public class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                return i;
            }
        }
        
        return -1;
    }
}

复杂度分析：

  • 线性扫描算法的时间复杂度为O(n)，其中n是数组的长度。算法需要遍历整个数组来查找目标值，因此最坏情况下需要执行n次比较操作。
  • 空间复杂度为O(1)，因为算法没有使用额外的空间，只需常数级别的额外空间。

相对于二分查找算法的O(log n)时间复杂度，线性扫描算法的时间复杂度较高。但在某些特定场景或者输入规模较小的情况下，线性扫描算法也可以快速解决问题。

综上所述，线性扫描算法适用于简单的问题或者规模较小的数据集，但在更大规模的数据集上，二分查找算法通常更具优势。

LeetCode运行结果：

方法三：递归

除了二分查找和线性扫描的方法，还可以使用递归的方法来搜索旋转排序数组。

该算法与二分查找算法类似，也是通过判断左右半边哪一边是有序的来决定向哪边继续查找。不同之处在于，该算法使用递归的方式实现，将数组的搜索范围不断缩小。

  1. 算法首先检查数组是否为空或者长度为0，如果是，则返回-1。然后调用递归函数 search 进行搜索，传入参数 nums 数组、目标值 target、搜索范围的左右端点索引 left 和 right。
  2. 在递归函数中，首先判断搜索范围是否合法，如果不合法，则返回-1。然后计算中间元素索引 mid。如果中间元素等于目标值，则返回 mid。
  3. 接着判断左半边是否有序（即 nums[left] <= nums[mid]）。如果是，则判断目标值是否在左半边的有序范围内。如果是，则继续在左半边递归查找；否则，在右半边递归查找。
  4. 如果左半边不是有序的，则右半边一定是有序的。判断目标值是否在右半边的有序范围内。如果是，则在右半边递归查找；否则，在左半边递归查找。
  5. 最后，如果循环结束仍未找到目标值，则返回-1。
public class Solution {
    public int search(int[] nums, int target) {
        if (nums == null || nums.length == 0) {
            return -1;
        }
        
        return search(nums, target, 0, nums.length - 1);
    }
    
    private int search(int[] nums, int target, int left, int right) {
        if (left > right) {
            return -1;
        }
        
        int mid = left + (right - left) / 2;
        
        if (nums[mid] == target) {
            return mid;
        }
        
        if (nums[left] <= nums[mid]) { // 左半边有序
            if (target >= nums[left] && target < nums[mid]) {
                return search(nums, target, left, mid - 1);
            } else {
                return search(nums, target, mid + 1, right);
            }
        } else { // 右半边有序
            if (target > nums[mid] && target <= nums[right]) {
                return search(nums, target, mid + 1, right);
            } else {
                return search(nums, target, left, mid - 1);
            }
        }
    }
}

复杂度分析：

时间复杂度：

  • 最好情况下，数组是完全有序的，每次都能通过比较找到目标值，时间复杂度为 O(log n)。
  • 最坏情况下，每次都只能排除一个元素，需要遍历整个数组，时间复杂度为 O(n)。
  • 平均情况下，假设数组中大致一半是有序的，一半是无序的，时间复杂度介于 O(log n) 和 O(n) 之间。

空间复杂度：

  • 每次递归调用会在栈上保存一些临时变量和返回地址，最大递归深度为 log n，因此空间复杂度为 O(log n)。

综合考虑，递归搜索旋转排序数组的算法在最坏情况下的时间复杂度为 O(n)，空间复杂度为 O(log n)。但如果数组是近似有序的或者目标值位于有序部分内，时间复杂度可以接近 O(log n)，效率较高。

需要注意的是，递归算法和二分查找算法类似，但由于需要额外的栈空间，因此可能会更慢。在处理超大规模数据时，可能会导致栈溢出问题。

LeetCode运行结果：

第三题

题目来源

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

题目内容

解决方法

方法一：二分查找

  1. 首先，我们定义一个长度为2的整数数组 result，并初始化为 {-1, -1}。这个数组表示目标值的开始位置和结束位置。
  2. 然后，我们使用两个辅助函数 findLeft 和 findRight 来分别查找目标值的开始位置和结束位置。
  3. 在 findLeft 函数中，我们使用二分查找来搜索目标值的开始位置。初始时，左边界 left 指向数组的第一个元素，右边界 right 指向数组的最后一个元素。在每次循环中，计算中间元素索引 mid，并将它与目标值进行比较。如果中间元素大于或等于目标值，则将右边界 right 缩小为 mid；否则，将左边界 left 扩大为 mid + 1。最后，返回 left 的值作为目标值的开始位置。如果目标值不存在，则返回 -1。
  4. 在 findRight 函数中，我们同样使用二分查找来搜索目标值的结束位置。不过这次的二分查找稍有不同。初始时，左边界 left 指向数组的第一个元素，右边界 right 指向数组的最后一个元素。在每次循环中，计算中间元素索引 mid，并将它与目标值进行比较。如果中间元素小于或等于目标值，则将左边界 left 扩大为 mid；否则，将右边界 right 缩小为 mid - 1。最后，返回 left 的值作为目标值的结束位置。如果目标值不存在，则返回 -1。
  5. 最后，在主函数 searchRange 中，我们首先判断特殊情况，即数组为空或长度为0的情况，直接返回初始化好的 result 数组。
  6. 然后，我们通过调用辅助函数 findLeft 和 findRight 分别得到目标值的开始位置和结束位置，并将它们存储在 result 数组中。
  7. 最后，返回 result 数组作为结果。
class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        int leftIndex = findLeft(nums, target);
        int rightIndex = findRight(nums, target);
        
        if (leftIndex <= rightIndex) {
            result[0] = leftIndex;
            result[1] = rightIndex;
        }
        
        return result;
    }
    
    private int findLeft(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        
        while (left < right) {
            int mid = left + (right - left) / 2;
            
            if (nums[mid] >= target) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        
        return nums[left] == target ? left : -1;
    }
    
    private int findRight(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        
        while (left < right) {
            int mid = left + (right - left) / 2 + 1;
            
            if (nums[mid] <= target) {
                left = mid;
            } else {
                right = mid - 1;
            }
        }
        
        return nums[left] == target ? left : -1;
    }
}

复杂度分析：

  • 时间复杂度：O(log n)。每次迭代都将搜索空间减半，因此时间复杂度为对数级别。
  • 空间复杂度：O(1)。仅使用了有限的额外空间来存储几个变量。

LeetCode运行结果：

方法二：线性扫描

除了二分查找，还可以使用线性扫描的方法来搜索排序数组中目标值的开始位置和结束位置。

  1. 我们首先遍历整个数组来查找目标值的开始位置。如果找到目标值，我们将其索引存储在 result[0] 中并立即退出循环。如果没有找到目标值，则 result[0] 保持为初始值 -1。
  2. 接着，我们再从数组的末尾开始向前遍历，查找目标值的结束位置。如果找到目标值，我们将其索引存储在 result[1] 中并立即退出循环。如果没有找到目标值，则 result[1] 保持为初始值 -1。
  3. 最后，我们返回存储了目标值开始位置和结束位置的 result 数组。
class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == target) {
                result[0] = i;
                break;
            }
        }
        
        if (result[0] != -1) {
            for (int j = nums.length - 1; j >= 0; j--) {
                if (nums[j] == target) {
                    result[1] = j;
                    break;
                }
            }
        }
        
        return result;
    }
}

复杂度分析：

  • 时间复杂度：O(n)。需要遍历整个数组，其中 n 是数组的长度。
  • 空间复杂度：O(1)。仅使用了有限的额外空间来存储几个变量。

因为二分查找的时间复杂度为 log n，而线性扫描的时间复杂度为 n，所以在数组较大且已排序的情况下，二分查找的性能更好。它减少了搜索空间的大小，使得平均查找次数更低。然而，在数组较小或未排序的情况下，线性扫描是一种简单有效的方法。

LeetCode运行结果：

方法三：双指针

除了二分查找和线性扫描，还有一种常用的方法是双指针法。这种方法适用于有序数组或部分有序数组，并且可以在 O(n) 的时间复杂度内找到目标值的开始位置和结束位置。

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int[] result = {-1, -1};
        
        if (nums == null || nums.length == 0) {
            return result;
        }
        
        int left = 0;
        int right = nums.length - 1;
        
        // 查找目标值的开始位置
        while (left <= right) {
            if (nums[left] == target && nums[right] == target) {
                result[0] = left;
                result[1] = right;
                break;
            }
            
            if (nums[left] < target) {
                left++;
            }
            
            if (nums[right] > target) {
                right--;
            }
        }
        
        return result;
    }
}

在上述代码中，我们使用两个指针 left 和 right 来标记搜索区间。通过不断更新指针的位置，我们可以确定目标值的开始位置和结束位置。

具体步骤如下：

  1. 初始化指针 left 和 right 分别指向数组的首尾元素。
  2. 当 left 指向的元素小于目标值时，将 left 向右移动一位。
  3. 当 right 指向的元素大于目标值时，将 right 向左移动一位。
  4. 如果 left 和 right 指向的元素都等于目标值，则找到了目标值的开始位置和结束位置。将结果存储在 result 数组中，并退出循环。
  5. 如果找不到目标值，则返回初始值为 -1 的 result 数组。

复杂度分析：

  • 使用双指针法的时间复杂度是 O(n)，其中 n 是数组的长度。在最坏的情况下，即目标值不在数组中或者目标值在数组中出现了 n 次，我们需要将指针 left 和 right 分别移动到数组的两端。因此，最多需要遍历整个数组一次，时间复杂度为 O(n)。
  • 空间复杂度是 O(1)，因为我们只需要使用有限的额外变量来记录指针的位置和存储结果数组。

需要注意的是，双指针法适用于有序数组或部分有序数组，如果数组无序，则双指针法无法正确找到目标值的开始位置和结束位置。

LeetCode运行结果：

正在奋斗的程序猿
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode:LeetCode代码（Java版）
06-30
《LeetCode：深入解析Java版解题策略》 在编程领域，LeetCode 是一个极受欢迎的在线平台，它提供了一系列的编程挑战，旨在提升开发者们的算法技能和问题解决能力。本篇文章将聚焦于使用Java语言在LeetCode上的解题...
用java刷leetcode-mtLeetCode:用java&scala刷leetcode
07-01
用java刷leetcode mtLeetCode 用 java & scala 刷 leetcode
怒刷LeetCode的第6天（Java版）
m0_74293254的博客
09-18 408
时间复杂度为O(mnlogn)，其中m是字符串的平均长度，n是字符串数组的长度。时间复杂度为O(mn)，其中m是最长公共前缀的长度，n是字符串数组的长度。空间复杂度为O(1)。时间复杂度为O(mn)，其中m是最短字符串的长度，n是字符串数组的长度。该算法使用二分查找来逐步缩小最长公共前缀的范围，时间复杂度为O(mnlogm)，其中m是最短字符串的长度，n是字符串数组的长度。如果当前索引位置超过了当前字符串的长度，或者当前字符在其他字符串的相同位置上的字符不相等，则表示不匹配，直接返回当前的公共前缀。
怒刷LeetCode的第5天（Java版）
m0_74293254的博客
09-18 151
如果我们将左指针向右移动一位，那么新的左指针对应的线段高度为 l'，右指针不变，那么新容器的底部长度为 r- (l'-l)，高度为 min(l', r)，因此容器容纳的水量为 (r-(l'-l)) * min(l', r)。计算某个元素时，可以考虑当前两条线段的高度和它们之间的距离，并且选择高度较小的一条作为瓶颈，即容器的高度，并计算容器的底部长度，即线段的距离。然后，从大到小遍历符号数组，每次查看给定的整数中有多少个当前符号所对应的数值，将其加入结果字符串，并用给定的整数减去已经加过的数值。
Java [leetcode 14] Longest Common Prefix
dkk37351的博客
05-03 44
小二好久没有更新博客了，真是罪过，最近在看linux的东西导致进度耽搁了，所以今晚睡觉前怒刷一题！ 问题描述： Write a function to find the longest common prefix string amongst an array of strings. 解题思路： 该问题就是找到所有数组字符串里面的最长相同前字串。所以我的思路是先找到数组中最短的那...
怒肝 Java 学习路线一条龙！
F_xiao_chou的博客
08-26 1620
文章为转载 请关注鱼皮好友 持续获取 有效学习知识 现在网上的编程资料实在太多了，而且人人肯定都说自己的最好，那就导致大家又不知道怎么选了。大部分的博主推荐资源，也就是把播放量高的视频说一遍，水一期视频，没有一条很清晰的学习路线。 所以今天我的这个 Java 学习路线就做做减法，给大家来个一条龙服务，Java 要学的知识点、对应的最佳学习资源和预计要花费的时间，都安排的明明白白的，不用选了，有计划了，也别再迷茫和纠结了，就无脑跟着学就行了。 大纲 实在太长了，没办法全部展开，只能放个大纲了。。...
刷LeetCode刷LeetCode刷LeetCode刷LeetCode
01-09
《刷LeetCode刷LeetCode刷LeetCode刷LeetCode》这个标题和描述虽然重复，但很明显是在强调通过反复练习LeetCode来提升编程技能的重要性。LeetCode是一个在线平台，它提供了大量的编程题目，涵盖算法、数据结构等多种...
用java刷leetcode-leetcode:leetcode
07-01
用java刷leetcode leetcode 虽然刷题被诟病已久，但不可否认，刷题确实可以锻炼我们的编程能力，相信每一个认真的刷题都会有经验。 在线编程评测的平台有很多，比如hihocoder、lintcode、leetcode，我们这里重点介绍...
leetcode-java:java版本的leetcode
07-23
《LeetCode Java版详解》 LeetCode 是一个广受欢迎的在线编程挑战平台，它提供了丰富的算法和数据结构问题，帮助开发者提升编程技能和解决实际问题的能力。本篇将重点介绍LeetCode上的Java版本实现，旨在深入理解...
leetcode日记（51）不同路径Ⅱ
s478527548的博客
07-25 721
琢磨了一下代码，原理是将上面的二维数组优化成了一维，记录开始位置到达每一行末尾的路径数。没有障碍物就将数目设为上一行路径数加上这一行路径数。需要注意的是遍历方向，按照上面这种思路需要先遍历列再遍历行，如果先遍历行，如果上一行末尾有障碍物那么下一行就通过不了。根据上一题改的代码如下，添加了对障碍物的判定，如果有障碍物则将数组值设为0。然后看了答案，答案说可以使用滚动数组优化，就又去搜了一下滚动数组的使用方法。和上一道题（无障碍物的最短路径）很像，但事实上比上一题多了优化方法。
C++——从前序与中序遍历序列构造二叉树leetcode105
最新发布
qq_50737873的博客
07-26 315
来源于leetcode官方解答，先序遍历的排布是[根节点，左子树，右子树]，中序遍历的排布是[左子树，根节点，右子树]，因此，从先序第一个元素可以找到中序中的根节点的位置，从而可以确定出左子树和右子树的节点数目，从而可以正确划分这一级的先序遍历的左右子树，对于左右子树内部也是对应的排列方式，因此可以考虑迭代，每次更新先序遍历和中序遍历的左右边界。preorder 和 inorder 均 无重复 元素。preorder 保证 为二叉树的前序遍历序列。inorder 均出现在 preorder。
【动态规划】力扣.213. 打家劫舍 II
sjsjs11的博客
07-25 455
同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。具体步骤和思路跟打家劫舍1的相同（主页有打家劫舍1的三种算法的详细思路），唯一区别是增加了首尾房子不能同时被偷的限制，所以可以分类讨论，然后返回出能偷到最大的金额即可。解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。输入：nums = [1,2,3,1]
LeetCode 2844.生成特殊数字的最少操作（哈希表 + 贪心）
AuRoRamth的博客
07-25 862
在来观察，被25整除，思考思考，你会发现25 * （1 ~ n）中的数他的后两位尾数是{25，50，75，00}，只要能发现这个规律，那这道题也就结束了，当然想不到也没关系，慢慢积累。那接下来就是两个指针i和j去遍历就行了，把{25，50，75，00}存到哈希表里面，如果key = num[i] + num[j]在哈希表里面找到了，就去更新一次ans的值。删除 num[3]、num[4] 和 num[6] ，得到数字 "2900" ，可以被 25 整除。在一次操作中，您可以选择。，表示一个非负整数。
力扣69题 x的平方根 二分查找法（简单易懂）
xiaoye7288的博客
07-25 324
一种人一种写法 建议大家用自己的二分做来题 不要一味去模仿他人的二分 加油！
数据结构与算法--【数组2】力扣练习 || 双指针 / 移除元素 / 数组排序
qq_44578108的博客
07-25 875
简单删除元素 / 指定某元素位置，其余元素位置相对不变双指针指向数组头。快指针扫描数组并判断，慢指针收集变化后的数组元素。不创建新数组，只覆盖原数组。对数组元素排序一个指针指开头，一个指针指结尾。判断两指针指向值大小，循环结束条件first <= last；for循环，while循环均可，本人更习惯while循环。使用malloc为新数组分配空间，注意，创建了新数组。
力扣1405.最长快乐字符串
Pisasama的博客
07-25 356
【代码】力扣1405.最长快乐字符串。
LeetCode206 反转链表
daishabby2486的博客
07-25 857
LeetCode206 反转链表的解题记录。
力扣94题（java语言）
bjjgff的博客
07-25 473
使用一个栈来模拟递归的过程，以非递归的方式完成中序遍历(使用栈可以避免递归调用的空间消耗。
java刷leetcode可以吗
06-09
当然可以！...使用Java刷LeetCode有很多好处，例如Java具有良好的跨平台性，易于学习和使用，拥有很多现成的库和框架等等。因此，如果您熟悉Java编程语言，那么使用Java刷LeetCode是一个不错的选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

正在奋斗的程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值