leetcode数组题目总结(Java)

最新推荐文章于 2023-07-06 21:56:40 发布
最新推荐文章于 2023-07-06 21:56:40 发布
阅读量687 收藏
点赞数
分类专栏： Leecode 文章标签： leetcode java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yabayaoya/article/details/129258784
版权

这里写目录标题

二分查找

704.二分查找

题目描述

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 :

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

解题思路

二分法条件：有序无重复。
二分法过程：和每次区间的中间的数相比较，大于则向后查找，小于则向前查找。
思路：由过程可得知，每次需要一个区间，也就是需要一个开始和结束的index，通过比较改变每次的index，每次与两个边界中间的元素做对比。
具体方法：左边界left，右边界right，那么应该比较的是索引为(right-left)/2+left的元素，如果left<=right（left<right）则终止循环，说明已经比较完了，是否有=是右边界决定的。

解题方法—迭代

class Solution {
    public int search(int[] nums, int target) {
        int left=0;
        int right=nums.length-1;
        while(left<=right){
            if(target>nums[(right-left)/2+left]){
                left=(right-left)/2+left+1;
            }else if(target<nums[(right-left)/2+left]){
                right=(right-left)/2+left-1;
            }else{
                return (right-left)/2+left;
            }
        }
        return -1;
    }
}

class Solution {
    public int search(int[] nums, int target) {
        int left=0;
        int right=nums.length;
        while(left<right){
            if(target>nums[(right-left)/2+left]){
                left=(right-left)/2+left+1;
            }else if(target<nums[(right-left)/2+left]){
                right=(right-left)/2+left;
            }else{
                return (right-left)/2+left;
            }
        }
        return -1;
    }
}

以上两种写法的区别就在于右边界是否为真正的索引，如果右边界是闭区间right=nums.length-1;，是开区间则是right=nums.length;

  • 第一个区别while(left<=right)循环就应可以等于，否则会有情况遍历不到，比如只有一个元素的时候直接不走循环了；

  • 第二个区别则是right的取值，要保持是否是后一位，right=(right-left)/2+left-1;，right=(right-left)/2+left;。

解题方法—递归

递归首先要确定终止条件，也就是left<=right（left<right），循环部分就是和区间中间的数字进行比较。
右边界依然可以有开闭两种写法。

class Solution {
    public int search(int[] nums, int target) {
        return twoPart(nums,target,0,nums.length-1);
    }
    private int twoPart(int[] nums, int target, int start, int end){
        if(start>end) return -1;
        if(target==nums[(end-start)/2+start]){
            return (end-start)/2+start;
        } else if(target<nums[(end-start)/2+start]){
            return twoPart(nums,target,start,(end-start)/2+start-1);
        }else{
            return twoPart(nums,target,(end-start)/2+start+1,end);
        }
    }
}

class Solution {
    public int search(int[] nums, int target) {
        return twoPart(nums,target,0,nums.length);
    }
    private int twoPart(int[] nums, int target, int start, int end){
        if(start>=end) return -1;
        if(target==nums[(end-start)/2+start]){
            return (end-start)/2+start;
        } else if(target<nums[(end-start)/2+start]){
            return twoPart(nums,target,start,(end-start)/2+start);
        }else{
            return twoPart(nums,target,(end-start)/2+start+1,end);
        }
    }
}

二分查找相关题目 - 35. 搜索插入位置

35. 搜索插入位置

题目描述

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
你可以假设数组中无重复元素。

示例 1:
输入: [1,3,5,6], 5
输出: 2

示例 2:
输入: [1,3,5,6], 2
输出: 1

示例 3:
输入: [1,3,5,6], 7
输出: 4

示例 4:
输入: [1,3,5,6], 0
输出: 0

提示:
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 为 无重复元素 的 升序 排列数组
-104 <= target <= 104

解题思路

本题中数组为升序无重复的数组，所以想到用二分搜索法提高效率。和704的差别只在于找不到时要返回插入的位置。

解题方法

注意插入的位置不是索引而是第几个，所以返回right即可。

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left=0;
        int right=nums.length;
        while(left<right){
            int mid=(right-left)/2+left;
            if(nums[mid]==target){
                return mid;
            }else if(target>nums[mid]){
                left=mid+1;
            }else{
                right=mid;
            }
        }
        return right;
    }
}

二分查找相关题目 - 34. 在排序数组中查找元素的第一个和最后一个位置

34. 在排序数组中查找元素的第一个和最后一个位置

题目描述

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：
输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：
输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：
输入：nums = [], target = 0
输出：[-1,-1]

提示：
0 <= nums.length <= 105
-109 <= nums[i] <= 109
nums 是一个非递减数组
-109 <= target <= 109

解题思路

这道题目与之前的区别在于元素可以重复，并其需要返回开始和结束的两个值。

寻找target在数组里的左右边界，有如下三种情况：
 - 情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4,
   5},target为6，此时应该返回{-1, -1} 
 - 情况二：target在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1} 
 - 情况三：target在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}

解题方法

class Solution {
    int[] searchRange(int[] nums, int target) {
        int leftBorder = getLeftBorder(nums, target);
        int rightBorder = getRightBorder(nums, target);
        // 情况一
        if (leftBorder == -2 || rightBorder == -2) return new int[]{-1, -1};
        // 情况三
        if (rightBorder - leftBorder > 1) return new int[]{leftBorder + 1, rightBorder - 1};
        // 情况二
        return new int[]{-1, -1};
    }

    int getRightBorder(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) {
                right = middle - 1;
            } else { // 寻找右边界，nums[middle] == target的时候更新left
                left = middle + 1;
                rightBorder = left;
            }
        }
        return rightBorder;
    }

    int getLeftBorder(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] >= target) { // 寻找左边界，nums[middle] == target的时候更新right
                right = middle - 1;
                leftBorder = right;
            } else {
                left = middle + 1;
            }
        }
        return leftBorder;
    }
}

移除元素

27. 移除元素

题目描述

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}
 

示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：
输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

解题思路1

我们知道数组不能直接删除只能覆盖其他值，所以当找到相等的元素要让后面的覆盖前面的。
因为相等的可能有多个元素，所以需要一个计数器，以便之后的元素知道向前覆盖几个元素。

解题方法1

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

解题思路2

双指针法
双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

  • 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
  • 慢指针：指向更新 新数组下标的位置

解题方法2

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

有序数组的平方

977. 有序数组的平方

题目描述

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：
输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

进阶：
请你设计时间复杂度为 O(n) 的算法解决本问题

解题思路

暴力解法肯定就是先平方后排序，但是这样时间复杂度最少也需要O(n + nlogn)。
时间为O(n)的方法肯定是只需要遍历一遍数组，最大值一定在数组的左右两端，定义两个指针分别从两端遍历再加到结果数组中。

解题方法

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] res=new int[nums.length];
        int i=0;
        int j=nums.length-1;
        int k=nums.length-1;
        while(i<=j){
            if(nums[i]*nums[i]>nums[j]*nums[j]){
                res[k--]=nums[i]*nums[i];
                i++;
            }else{
                res[k--]=nums[j]*nums[j];
                j--;
            }
        }
        return res;
    }
}

长度最小的子数组

209.长度最小的子数组

题目描述

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：
输入：target = 4, nums = [1,4,4]
输出：1

示例 3：
输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：
1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

进阶：
请尝试设计一个 O(n log(n)) 时间复杂度的解法。

解题思路

双循环显然是时间复杂度是n²。
滑动窗口思想：不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。
定义两个指针left、right，一个快一个慢，计算指针之间的值sum，并记录窗口的size；
若是>=target，right则向后移动，并且同时sum应减去i位置的值，注意这里是while循环，不一定只减去1个才<sum，同时判断区间的size是否更小并记录。

解题方法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left=0;
        int sum=0;
        int result=nums.length+1;
        for(int right=0;right<nums.length;right++){
            sum+=nums[right];
            while(sum>=target){
                int min=right-left+1;
                if(min<result){
                    result=min;
                }
                sum-=nums[left];
                ++left;
            }
        }
        if(result==nums.length+1) return 0;
        return result;
    }
}

长度最小的子数组相关题目 - 904. 水果成篮

904. 水果成篮

题目描述

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

  • 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
  • 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
  • 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

示例 1：
输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。

示例 2：
输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：
输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：
输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。

提示：
1 <= fruits.length <= 105
0 <= fruits[i] < fruits.length

解题思路

既然是相关题目，那么它和长度最小的子数组的相关性在哪里呢？
收集水果只有两个篮子，也就是只有两个种类的水果可以收集，且连续，所以滑动窗口中包含两个种类，数量是右边界-左边界+1。
那么left的变换规则是什么呢？
定义一个change，表示当前right的上一个不同种类水果的起始位置，也就是change的上一个也一定不相同，right如果和上一个&&上上一个不同，left则需更新到上一个的起始位置。
只要right和change不同，就需要更新change。

解题方法
class Solution {
    public int totalFruit(int[] fruits) {
        if(fruits.length<3) return fruits.length;
        int left=0;
        int change=0;
        int result=1;
        for(int right=1;right<fruits.length;right++){
        	//change就是right的前一个，如果right为第三种水果则需要更新left
            if(change-1>=0&&fruits[right]!=fruits[change-1]&&fruits[right]!=fruits[change]){
                left=change;
            }
            //只要right和change不同，就需要更新change。
            if(fruits[right]!=fruits[change]){
                change=right;
            }
            if(right-left+1>result) result=right-left+1;
        }
        return result;
    }
}

另外一个是官方解法，用HashMap保存采摘的水果，如果超过2个，则需要将key最左边种类的水果全部清除并更新left。

class Solution {
    public int totalFruit(int[] fruits) {
        int n = fruits.length;
        //建立哈希表 int int类型
        Map<Integer, Integer> cnt = new HashMap<Integer, Integer>();
        int left = 0, ans = 0;
        for (int right = 0; right < n; ++right) {
            //getOrDefault() 获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
            //left和right分别表示子数组（窗口）的左右边界，同时利用哈希表来存储这个窗口内的数以及**出现的次数**。
            cnt.put(fruits[right], cnt.getOrDefault(fruits[right], 0) + 1);//key是存储在窗口内的数，value是出现的次数
            while (cnt.size() > 2) {//如果哈希表大小大于2，那就移动left将fruits[left]从哈希表中移除，直到满足要求为止。
                cnt.put(fruits[left], cnt.get(fruits[left]) - 1);//将（最左number，最左index）键/值对添加到 hashMap 中
                //如果fruits[left]在哈希表中出现的次数减少为0，那么要将其key值移出，此时哈希表大小=2，继续循环。
                if (cnt.get(fruits[left]) == 0) {//key值等于0 相当于left挪动index+1次
                    cnt.remove(fruits[left]);
                }
                left++;
            }
            ans = Math.max(ans, right - left + 1);
        }
        return ans;
    }
}

长度最小的子数组相关题目 - 76. 最小覆盖子串

76. 最小覆盖子串

题目描述

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 “” 。

注意：
对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：
输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：
输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串。

示例 3:
输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

提示：
m == s.length
n == t.length
1 <= m, n <= 105
s 和 t 由英文字母组成
进阶：你能设计一个在 o(m+n) 时间内解决此问题的算法吗？

解题思路

依然是滑动窗口的思想，窗口内是s的子串。

  • 如果子串包含t，则left向右移动。
  • 如果子串不包含t所有字符，则right向右移动。

如何判断t中的字符是否包含在s中也是一个难点，t中字符可以重复，t的顺序不重要。
使用sum表示s子串中包含t的字符的个数，超过个数就不再增加。

解题方法

以下为官方解法。

class Solution {
    public String minWindow(String s, String t) {
    	//将s和t转换为字符数组
        char[] chs1 = s.toCharArray();
        char[] chs2 = t.toCharArray();
        
        //cnt是固定的，记录t中各个字符的频次，直接以字符的asc码为下标
        int[] cnt = new int[128];
        for(char ch : chs2) {
            cnt[ch]++;
        }
        
        //sum计数，如果t中所有元素都存在在s中则－为0
        int sum = chs2.length;
        int left = 0, right = 0; //[left, right)
        
        //记录长度最小时的下标
        int p1 = -1, p2 = -1;
        while(left < chs1.length && right < chs1.length) {
        	//如果t中的字符在s中存在，也就是以right为下标的s中的字符在cnt数组中为下标时元素大于0
        	//子串还没有完全包含t，right++
            if(cnt[chs1[right++]]-- > 0) {
                sum--;
            }   
            //子串包含t，left要向右移动
            while(sum == 0) {
            	//计算是否为最小长度
                if(p1 == -1 || right-left < p2-p1) {
                    p1 = left;
                    p2 = right;
                }
                
                if(cnt[chs1[left++]]++ >= 0)
                    sum++;
            } 
        }
        return p1==-1 ? "" : s.substring(p1, p2);
    }
}

59. 螺旋矩阵 II

59. 螺旋矩阵 II

题目描述

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
在这里插入图片描述

示例 1：
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

示例 2：
输入：n = 1
输出：[[1]]

提示：
1 <= n <= 20

解题思路

螺旋的过程：行从左到右，列从上到下，行从右到左，列从下到上，不断循环往复的过程

解题方法

模拟螺旋的过程，边界条件左闭右开

class Solution {
    public int[][] generateMatrix(int n) {
        int result[][]=new int[n][n];
        int sum,start,offset,i,j;
        start=0;//每次循环开始的位置
        sum=offset=1;
        //sum用来表示要填充的数字，每次＋1
        //offset用来控制循环的次数，表示要循环几圈
        while(offset<=n/2){
        	//从左到右
            for(j=start;j<n-offset;j++){
                result[start][j]=sum++;
            }
            //从上到下
            for(i=start;i<n-offset;i++){
                result[i][j]=sum++;
            }
            //从右到左
            for(;j>=offset;j--){
                result[i][j]=sum++;
            }
            //从下到上
            for(;i>=offset;i--){
                result[i][j]=sum++;
            }
            offset++;
            start++;
        }
        //中间点
        if (n % 2 == 1) {
            result[start][start] = sum;
        }
        return result;
    }
}

螺旋矩阵 II - 54. 螺旋矩阵

54. 螺旋矩阵

题目描述

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
在这里插入图片描述

解题思路

上一题是知道填充数求矩阵，这一题是知道矩阵，求螺旋数组。
本题要考虑不一定是正方形矩阵的情况，所以循环的圈数为Math.min(m,n)/2 + Math.min(m,n)%2;
如果只有一行，list便会重复添加从右到左，所以最后result = result.subList(0,m*n);，只保留m×n个元素

解题方法
class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> result=new ArrayList<Integer>();
        int m = matrix.length;
        int n = matrix[0].length;
        //需要转的圈数
        int cycle = Math.min(m,n)/2 + Math.min(m,n)%2;
        int offset=1;
        int start,i,j;
        start=0;
        while(offset<=cycle){
           
        	//从左到右
            for(j=start;j<matrix[0].length-offset;j++){
                result.add(matrix[start][j]);
            }
            //从上到下
            for(i=start;i<matrix.length-offset;i++){
                result.add(matrix[i][j]);
            }
            //从右到左
            for(;j>=offset;j--){
                result.add(matrix[i][j]);
            }
            //从下到上
            for(;i>=offset;i--){
                result.add(matrix[i][j]);
            }
            offset++;
            start++;
        }
        if (m%2 != 0 && n%2 != 0) {
            result.add(matrix[m/2][n/2]);
        }
        result = result.subList(0,m*n);
        return result;
    }
}
LeetCode编程题汇总（java实现）
qq_45824565的博客
03-14 490
26.删除排序数组中的重复项 java代码： class Solution { public int removeDuplicates(int[] nums) { int a=0; for(int i=1;i<nums.length;i++){ if(nums[a]!=nums[i]) { ...
leetcode总结——数组篇
weixin_45680007的博客
02-17 707
快慢指针：环形数组，最多出现两次的数组 pat型：除开自己的以外的乘积 Map：两数和/三数和/四数和，播放磁带，01数组 滑动窗口：最长不重复子串,t步内差小于k 首尾指针：水桶容量 贪心算法：合并区间，跳跃数组，矩阵面积 计算机数字转化 环形数组： 给定一个含有正整数和负整数的环形数组 nums。 如果某个索引中的数 k 为正数，则向前移动 k 个索引。相反，如果是负数 (-k)，则向后移动 ...
LeetCode(周刷5题篇)--[JAVA]
心态的博客
06-11 612
LeetCode(周刷5题篇)--[JAVA]你能多久做完这5题？
【LeetCode与《代码随想录》】数组篇：做题笔记与总结-Java版
karshey的博客
11-23 457
代码随想录地址 是学习过程中的笔记！图来自代码随想录。 文章目录理论题目704. 二分查找35. 搜索插入位置34. 在排序数组中查找元素的第一个和最后一个位置69. x 的平方根367.有效的完全平方数 理论 数组是存放在连续内存空间上的相同类型数据的集合。 数组下标都是从0开始的。 数组内存空间的地址是连续的。 因此，我们在添加和删除元素的时候要移动数组内的其他元素。 注意：关于C++的vector，它是容器，不是数组——数组里的元素只能覆盖，不能删除。 二维数组在内存的空间地址也是连续的。 题目
新手Leetcode 数组简单篇（附解题思路及JAVA代码）
qq_50438521的博客
03-04 584
1. Java怎么返回数组 ------ 具体见0001 两数之和 暴力法下面的补充 2. 用哈希表降低双重遍历的时间复杂度（代价是空间复杂度的增加）------- 具体见0001 两数之和 哈希表法的思路和算法二 3. 用快慢指针遍历比较数组元素及修改数组元素 ------- 具体见0026 删除有序数组中的重复项的思路和算法三 , 0027 移除元素的思路和算法四 4. 二分法查找目标数组元素 ------- 具体见0035 搜索插入位置的思路和算法五 , 0034
JAVA编程题（LeetCode)
weixin_49811734的博客
01-15 683
1.
leetcode数组下标大于间距-algorithm_java:实现数据结构和算法
06-30
leetcode数组下标大于间距 implement data structure and algorithms data_struct: 主要包括数据结构的java实现 1.数组 2.并查集 3.图 4.链表 5.队列 6.栈 7.树 divide_conquer:分治 1.活动选择问题 2.输入一个整形...
leetcode数组下标大于间距-leet-code:LeetCode刷题笔记
06-30
leetcode数组下标大于间距 LeetCode刷题笔记 创建于2019年12月31日，最近更新于2020年3月27日 链表 【简单难度】 【中等难度】 【困难难度】 ★ ★ ★ ★ 栈 【简单难度】 【中等难度】 【困难难度】 ★ ★ 堆与队列...
leetcode数组中元素出现次数-LeetCode:力扣问题
06-30
在LeetCode的"LeetCode-master"压缩包中，可能包含了这些问题的解题代码示例，涵盖多种语言如Java、Python、C++等。通过阅读和学习这些代码，你可以加深对上述算法的理解，并提升编程技能。同时，不断练习LeetCode上...
leetcode数组刷题总结与分析
ZHOUJIAN_TANK的博客
03-30 998
文章目录题目一：两数之和题目15、三数的和 题目一：两数之和 分析：要求求数组中两个数的和=target，关键是如何找到这两个数，也就是从数组中查找两个数的变形，那么首先可以使用暴力法 对于每个值nums[i]，可以遍历数组中的其他值，来进行判断，=两个值的和是否等于target 时间复杂度为O(n^2); 上面的复杂度太高，那么是否有某种方法进行改进呢？是否可以用空间换时间的策略，可以尝试...
Java写回文数（LeeCode 0009题）
m0_57986416的博客
09-24 187
Java写回文数（LeeCode 0009题）
LeetCode(力扣)经典算法题-day01-java语言实现
weixin_54237806的博客
12-29 348
LeetCode(力扣)经典算法题-day01-java语言实现数组旋转
leetcode 704. 二分查找JAVA
turn_sole的博客
02-08 775
二分查找有两种实现方式，迭代和递归，其时间复杂度为.主要思想是将目标值与数组的中间值做对比，若小于中间值，则在数组的前半段找，否则在后半段找。 1、迭代法不会增加多余的内存空间，java代码如下： class Solution { public int search(int[] nums, int target) { int left = 0; int right = nums.length-1; while(left <= right){
Java-二分查找-leetcode 704、35、34
最新发布
macdiii的博客
07-06 119
我一开始的思路是二分法，在找到target之后，无限判断是否有与target相同的数，进而扩大start和end的范围。），因为&&如果前面的是false那就不判断后面的了，所以我在前面判断是否数组索引越界，然后后面放索引对应值与target的判定，这样就避免了OOR。难点主要在插入位置的确定上，按照解题思路里的话来说，如果nums中不存在target，那么退出循环，left和right肯定是交叉的。U1S1，这个非递减数组，很离谱，其实就是升序数组的意思，真的很无语。佬们的思路也很简单，找到。
数据结构part1——数组
qq_45725126的博客
07-29 239
二分法查找 35.搜索插入位置 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 请必须使用时间复杂度为 O(log n) 的算法。 示例 1: 输入: nums = [1,3,5,6], target = 5 输出: 2 示例 2: 输入: nums = [1,3,5,6], target = 2 输出: 1 示例 3: 输入: nums = [1,3,5,6], target = 7 输出: 4 class Solution:
算法练习（6）
qq_60179418的博客
07-10 515
题目一：玩筹码（难度：简单）来源：力扣（LeetCode） 链接：https://leetcode.cn/problems/minimum-cost-to-move-chips-to-the-same-position思路：统计奇数和偶数的个数取最小值即可 题目二：移除元素（难度：简单）来源：力扣（LeetCode） 链接：https://leetcode.cn/problems/remove-element思路：通过while循环遍历数组，相同则使用del删除列表中元素，同时保持下标不变。 题
数据结构之数组练习
qq_62309585的博客
09-07 363
数组练习
程序员面试金典： 9.4树与图 4.3给定一个有序整数数组，元素各不相同且按升序排列，创建一颗高度最小的二叉查找树。
qingyuanluofeng的专栏
12-27 683
#include #include using namespace std; /* 问题：给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一颗高度最小的二叉查找树。 分析：二叉查找树是左孩子<结点<右孩子。二叉查找树关键的部分应该是调整树的结点，使得平衡。高度最小 的二叉查找树，应该是平衡的二叉查找树。 中序遍历的结果是：左中右，那么遍历 问题转化为如何
34. 在排序数组中查找元素的第一个和最后一个位置给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标
m0_51919640的博客
11-22 561
在排序数组中查找元素的第一个和最后一个位置给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标
LeetCode数组题型与性能分析
"LeetCode数组类知识点&题型总结，包括无序数组、有序数组的特点与应用场景，以及动态数组的概念。" 在编程中，数组是一种基础且重要的数据结构，它在LeetCode等算法题目中扮演着核心角色。数组提供了一种有效的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值