数组部分总结

我不是小哥哥

已于 2024-03-04 10:29:08 修改

阅读量2.3k

点赞数

分类专栏： Leetcode 文章标签： leetcode

于 2022-03-24 10:18:58 首次发布

本文链接：https://blog.csdn.net/m0_48941999/article/details/123704086

版权

Leetcode 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

如果新数组的长度小于源数组的长度，那么新数组将截取源数组的前几个元素。
如果源数组中的元素是对象引用，那么新数组中的元素将仍然引用相同的对象，这意味着对新数组的修改可能会影响到源数组。比如int[] num2 = num1;
如果源数组包含基本数据类型（如int、char等），新数组将包含这些基本数据类型的默认值，如0或’\0’。

总结
在处理数组时，选择合适的复制方法取决于您的具体需求。以下是一些使用这些方法的一些建议：

如果您需要高效的底层复制操作，并且能够手动计算起始位置和元素数量，那么System.arraycopy可能是一个不错的选择。
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
如果您想要创建一个新数组，其长度与源数组相同，并且将源数组的内容全部复制到新数组中，那么Arrays.copyOf是一个方便的选择。
copyOf(T[] original, int newLength)
如果您需要复制源数组的一部分内容到一个新数组中，那么Arrays.copyOfRange是最适合的。
copyOfRange(U[] original, int from, int toe)

2.数组和List的相互转换

数组转list:
asList:

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arrays));

List转数组：

 //使用toArray(T[] a)方法（更推荐）
 String[] array2 = testList.toArray(new String[testList.size()]);
//要转换的list集合
 List<String> testList = new ArrayList<String>(){{add("aa");add("bb");add("cc");}};

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

给你一个有序数组 nums ，请你原地删除重复出现的元素，使得出现次数超过两次的元素只出现两次，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

分析：可以将2推广到保留k个元素

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums.length <= 2)    return nums.length;
        int i = 2, j = 2;   //j是慢指针， i是快指针
        while(i < nums.length){
            if(nums[i] == nums[j-2]){   //注意是nums[j-2]，因为是新数组保留的k个元素，所以要在新数组中比较
                i++;
            }else{
                nums[j] = nums[i];
                j++;
                i++;
            }
        }
        return j;
    }
}

189. 轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

方法：
借助中间数组：

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] newArr = new int[n];
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        System.arraycopy(newArr, 0, nums, 0, n);
    }
}

翻转数组：

class Solution {
public:
    void reverse(vector<int>& nums, int start, int end) {
        while (start < end) {
            swap(nums[start], nums[end]);
            start += 1;
            end -= 1;
        }
    }

    void rotate(vector<int>& nums, int k) {
        k %= nums.size();
        reverse(nums, 0, nums.size() - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.size() - 1);
    }
};

45. 跳跃游戏 II

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

0 <= j <= nums[i]
i + j < n
返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
示例 2:

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

class Solution {
    public int jump(int[] nums) {
        int steps = 0, maxRigth = 0, end = 0;
        //当到达nums.length-1时以及到终点了，所以不用遍历最后一个元素
        for(int i = 0; i < nums.length-1; i++){
            // 继续往下遍历，统计边界范围内，哪一格能跳得更远，每走一步就更新一次能跳跃的最远位置下标
            //由于题目说肯定能到达终点，所有不用判断maxRight和当前下标的关系
            maxRigth = Math.max(maxRigth, i + nums[i]);
            // 如果到达了边界，那么一定要跳了，下一跳的边界下标就是之前统计的最优情况maxPosition，并且步数加1
            if(i == end){
                //更新最大边界以及步数
                end = maxRigth;
                steps++;
            }
        }
        return steps;
    }
}

238. 除自身以外数组的乘积

给你一个整数数组 nums，返回数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

题目数据保证数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位整数范围内。

请不要使用除法，且在 O(n) 时间复杂度内完成此题。

示例 1:

输入: nums = [1,2,3,4]
输出: [24,12,8,6]
示例 2:

输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

分析：难点在于不能使用除法，只能用乘法计算。
使用2个辅助数组，left[i]表示i左侧所有数字的乘积，right[i]表示i右侧所有数字的乘积
由于除自身以外数组的乘积，因此当前下标的乘积res[i]=left[i] * right[i];

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int n = nums.length;
        int[] left = new int[n];
        int[] right = new int[n];
        left[0] = 1;
        right[n-1] = 1;
        for(int i = 1; i < n; i++){
            left[i] = nums[i-1] * left[i-1];
        }
        for(int i = n-2; i >= 0; i--){
            right[i] = right[i+1] * nums[i+1];
        }
        int[] res = new int[n];
        for(int i = 0; i < n; i++){
            res[i] = left[i] * right[i];
        }
        return res;
    }
}

二分查找：

在返回结果时，有可能不等于target注意判断是返回>=，还是<=的结果。

704.二分查找

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

69.x 的平方根

704.二分查找

二分查找主要用于有序数组，且无重复元素

边界问题：

左闭右闭：

left可以等于right，此时循环的条件为left <= right;

判断当mid 不等于target时，此时left = mid + 1或者right = mid-1;

左闭右开：

left不能等于right，此时循环的条件为left < right;

判断当mid 不等于target时，此时left = mid + 1或者right = mid;

左闭右开写法：

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

69.x 的平方根

用二分法求平方根且要求只取整数， $a^2 <= x$ ，所以用二分时，如果最后跳出循环后应该取小的一个；

class Solution {
    public int mySqrt(long x) {
        long left = 0;
        long right = x;
        while(left <= right){
            long mid = (right - left)/2 + left;
            long temp = mid * mid;
            if(temp < x){
                left = mid + 1;
            }else if(temp > x){
                right = mid - 1;
            }else{
              	return (int)mid;
            }

        }
        return left;
    }
}

其他：可以用牛顿迭代法，二次收敛，比二分查找更快

快慢指针：

27.移除元素

844.比较含退格的字符串

快指针遍历数组，慢指针填补相应的元素。

移除元素

class Solution {
    public int removeElement(int[] nums, int val) {

        // 快慢指针
        int fastIndex = 0;
        int slowIndex;
        for (slowIndex = 0; fastIndex < nums.length; fastIndex++) {
            if (nums[fastIndex] != val) {
                nums[slowIndex] = nums[fastIndex];
                slowIndex++;
            }
        }
        return slowIndex;

    }
}

844.比较含退格的字符串

方法一、由于先进后出的特征，考虑用栈；这里用StringBuffer代替stack更方便。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        String a = build(s);
        String b = build(t);
        return a.equals(b);
    }
    public String build(String s){
        StringBuffer s1 = new StringBuffer("");
        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == '#' && s1.length() > 0){
                s1.delete(s1.length()-1, s1.length());
            }else if(s.charAt(i) != '#'){
                s1.append(s.charAt(i));
            }
        }
        return s1.toString();
    }
}

方法二、用双指针
在这里插入图片描述

滑动窗口：

核心思想：扩展右边界，缩短左边界，并适时更新数据。

209.长度最小的子数组

904.水果成篮

76.最小覆盖子串

209.长度最小的子数组

窗口内是什么？
- 窗口就是满足其和 ≥ s 的长度最小的连续子数组。
如何移动窗口的起始位置？
- 窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。
如何移动窗口的结束位置？
- 窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针。

for (int right = 0; right < nums.length; right++) {
  sum += nums[right];
  while (sum >= s) {
    result = Math.min(result, right - left + 1);
    sum -= nums[left++];
  }
}

水果成篮

1, 使用map保存窗口中数字出现的次数，因为数字不是很大。可以使用数组模拟hash。
2，右指针移动时，如果发现是一个没有出现过的数字，就把cnt++
3，如果cnt个数超过了设定的窗口大小则开始收缩窗口
4，直到窗口中数字被减少到0. 此时将cnt–，退出收缩流程

5, 更新水果的最大数目结果应该在right扩张的时候，在窗口缩小时不考虑。

    public int totalFruit(int[] fruits) {
        if(fruits.length <= 2)  return fruits.length;
        int ans = 0, left = 0;
        HashMap<Integer, Integer> window = new HashMap<Integer, Integer>();
        for (int right = 0; right < fruits.length; right++) {
            window.put(fruits[right], window.getOrDefault(fruits[right], 0) + 1);
            while (window.size() > 2){
                window.put(fruits[left], window.getOrDefault(fruits[left], 0) - 1);
                if(window.get(fruits[left]) == 0) window.remove(fruits[left]);
                left++;
            }
            ans = Math.max(ans, right - left + 1);
        }
        return ans;
    }

其他：

Java Map:

entrySet()的返回值也是返回一个Set集合，此集合的类型为Map.Entry。

Map.Entry是Map声明的一个内部接口，此接口为泛型，定义为Entry<K,V>。它表示Map中的一个实体（一个key-value对）。接口中有getKey(),getValue方法。

由以上可以得出，遍历Map的常用方法：

Map map = new HashMap();
Iterator iterator = map.entrySet().iterator();
while(iterator.hasNext()) {
		Map.Entry entry = iterator.next();
		Object key = entry.getKey();
}

螺旋矩阵：

螺旋矩阵II

N数之和：

两数之和

三数之和

四数之和

四数之和II

两数之和：

题目：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的两个整数，并返回他们的数组下标。

分析：

这道题主要是快速查找，因此使用Hash map，保存 -nums[i]和下标。时间复杂度 $O (n)$

由于返回的是下标，所以不能用快慢指针

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        
        for (int i = 0; i < nums.length; i++){
            if(map.containsKey(target - nums[i])){
                int j = map.get(target - nums[i]);
                return new int[]{i, j};
            }else{
                map.put(nums[i], i);
            }
        }
        return new int[]{-1, -1};
    }
}

三数之和：

题目：

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

分析：

由于要找的是不重复的数组，哈希表很难去重，所以考虑用快慢指针。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> re = new ArrayList<>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
            int target = -nums[i];
            //去重，必须用nums[i] == nums[i-1]
            if(i > 0 && nums[i] == nums[i-1])   i++;
            int left = i+1, right = nums.length-1;
            while(left < right){
                if(nums[left] + nums[right] < target){
                    left++;
                }else if(nums[left] + nums[right] > target){
                    right--;
                }else{
                    List<Integer> temp = Arrays.asList(nums[i], nums[left], nums[right]);
                    re.add(temp);
                  //必须先添加后去重
                    while (left < right && nums[left] == nums[left+1])   left++;
                    while (left < right && nums[right] == nums[right-1])    right--;
                    left++;
                    right--;
                }
            }
        }
        return re;
    }


}

四数之和：

题目：

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d = target相等？找出所有满足条件且不重复的四元组。

分析：

由于要找的是不重复的数组，哈希表很难去重，所以考虑用快慢指针。

四数之和，相比三叔之和多加了一重循环，多一次判断去重，此次去重必须是j > i+1

class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> temp = new ArrayList<Integer>();
        Arrays.sort(nums);
        for (int i = 0; i < nums.length; i++) {
          //去重，必须用nums[i] == nums[i-1]
          //如果用nums[i] == nums[i+1]， 会忽略当target = 0，[0，0，0，0]类似这种情况[a,a,b,c]
            if(i > 0 && nums[i] == nums[i-1]) continue;
            for (int j = i+1; j < nums.length; j++) {
              //必须时j > i+1，注意不要写成j > 0, 当target = 0，[0，0，0，0]时，同样会直接跳过
                if(j > i+1 && nums[j] == nums[j-1]) continue;
              //if (nums[i] + nums[j] >= target)	continue;
              //上述这种对于当target = 0， [0，0，0，0]时，是有问题的，所以不能加
                int left = j+1, right = nums.length - 1;
                while(left < right){
                    if(nums[i] + nums[j] + nums[left] + nums[right] > target){
                        right--;
                    }else if(nums[i] + nums[j] + nums[left] + nums[right] < target){
                        left++;
                    }else{
                        temp = Arrays.asList(nums[i], nums[j], nums[left], nums[right]);
                        res.add(temp);
                      //必须先添加后去重
                        while(left < right && nums[left] == nums[left+1])   left++;
                        while(left < right && nums[right] == nums[right-1])   right--;
                        
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }

}

// 这种剪枝是错误的，这道题目target 是任意值
// if (nums[k] > target) {
//     return result;
// }

四数相加II：

题目：

给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

分析：

这道题由于是从4个四个数组中分别取一个元素判断nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0，所以不用考虑重复情况。根据两数之和，可以使用hash表能够尽快匹配。

先计算temp = nums1[i] + nums2[j] ，存入hash表，时间复杂度为 $O(n^2)$
然后在将nums3[k] + nums4[l]之和与hash表匹配，计算是否等于0。
用res记录符合条件的结果res += A.get(temp);

class Solution {
    public int fourSumCount(int[] nums1, int[] nums2, int[] nums3, int[] nums4) {
        HashMap<Integer, Integer> A = new HashMap<>();
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                int temp = nums1[i] + nums2[j];
                A.put(temp, A.getOrDefault(temp, 0) + 1);
            }
        }
        int res = 0;
        for (int i = 0; i < nums3.length; i++) {
            for (int j = 0; j < nums4.length; j++) {
                int temp = -1 * (nums3[i] + nums4[j]);
                if(A.containsKey(temp)){
                    res +=  A.get(temp);
                }
            }
        }
        return res;
    }
}

我不是小哥哥

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组部分总结

二分查找：在返回结果时，有可能不等于target注意判断是返回>=，还是<=的结果。704.二分查找34.在排序数组中查找元素的第一个和最后一个位置69.x 的平方根704.二分查找二分查找主要用于有序数组，且无重复元素边界问题：左闭右闭：left可以等于right，此时循环的条件为left <= right;判断当mid 不等于target时，此时left = mid + 1或者right = mid-1;左闭右开：left不能等于right，此时循环的条
复制链接

扫一扫