LeetCode hot 100 学习记录 day 2

Integer方法

由轮转数组到Interger方法、System方法

轮转数组：

涉及到的方法：

System.arraycopy(newArr, 0, nums, 0, n)

nums.assign(newArr.begin(), newArr.end());

方法介绍：

public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
//复制指定源数组src到目标数组dest。
//复制从src的srcPos索引开始，复制的个数是length，
//复制到dest的索引从destPos开始。

除自身以外数组的乘积

从$O(n^2)$到$O(n)$的简化

题目：

给你一个整数数组 $nums$，返回 数组 $answer$ ，其中 $answer[i]$ 等于 $nums$ 中除 $nums[i]$ 之外其余各元素的乘积 。题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。请 不要使用除法，且在 O(n) 时间复杂度内完成此题。

算法示意：

原数组：       [1       2       3       4]
左部分的乘积：   1       1      1*2    1*2*3
右部分的乘积： 2*3*4    3*4      4      1
结果：        1*2*3*4  1*3*4   1*2*4  1*2*3*1

代码实现：

//来自leetcode的Krahets大神
class Solution {
    public int[] productExceptSelf(int[] nums) {
        int len = nums.length;
        if (len == 0) return new int[0];
        int[] ans = new int[len];
        ans[0] = 1;
        int tmp = 1;
        for (int i = 1; i < len; i++) {
            ans[i] = ans[i - 1] * nums[i - 1];
        }
        for (int i = len - 2; i >= 0; i--) {
            tmp *= nums[i + 1];
            ans[i] *= tmp;
        }
        return ans;
    }
}

缺失的第一个正数

排序的时间复杂度下界为$O(n*log(n))$，特殊情况下为$O(n)$

题目：
给你一个未排序的整数数组 $nums$ ，请你找出其中没有出现的最小的正整数。请你实现时间复杂度为 $O(n)$ 并且只使用常数级别额外空间的解决方案。

哈希表可以实现将时间为$O(n^2)$的算法改进为时空复杂度都为$O(n)$
建立哈希表会产生$O(n)$的空间复杂度
实际上没出现的最小正整数只能在[1,N+1]中，如果 [1,N] 都出现了，那么答案是N+1，否则答案是 [1,N] 中没有出现的最小正整数。
通过对数组打上标记，将数组看作一个哈希表：
我们对数组进行遍历，对于遍历到的数 x，如果它在 [1,N] 的范围内，那么就将数组中的第 x−1 个位置（注意：数组下标从 0开始）打上「标记」。在遍历结束之后，如果所有的位置都被打上了标记，那么答案是 N+1，否则答案是最小的没有打上标记的位置加 111
代码实现：

class Solution {
    public int firstMissingPositive(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; ++i) {
            if (nums[i] <= 0) {
                nums[i] = n + 1;
            }
        }
        for (int i = 0; i < n; ++i) {
            int num = Math.abs(nums[i]);
            if (num <= n) {
                nums[num - 1] = -Math.abs(nums[num - 1]);
            }
        }
        for (int i = 0; i < n; ++i) {
            if (nums[i] > 0) {
                return i + 1;
            }
        }
        return n + 1;
    }
}

参考链接

https://leetcode.cn/problems/product-of-array-except-self/
https://leetcode.cn/problems/rotate-array/
https://leetcode.cn/problems/first-missing-positive/