第一题
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1：
输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。 示例 2：
输入：nums = [3,2,4], target = 6 输出：[1,2] 示例 3：
输入：nums = [3,3], target = 6 输出：[0,1]
提示：
2 <= nums.length <= 104 -109 <= nums[i] <= 109 -109 <= target <= 109 只会存在一个有效答案 进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
来源：力扣（LeetCode） 链接：leetcode.cn/problems/tw… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
- 一个key，一个value，而且只会出现一次，这不就是hashMap吗，所以用hashMap来解
- 然后观察一下，结果要求返回的是下标，那要怎么搞呢，肯定要记录下标
- key= target-nums[i] value = i 这样就满足了两个下标了
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int i = 0;i<nums.length;i++){
int temp = target-nums[i];
if(map.containsKey(nums[i])){
return new int[]{map.get(nums[i]),i};
}else{
map.put(temp,i);
}
}
return null;
}
}
第二题
给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
示例 1：
输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3 输出：[1,2,2,3,5,6] 解释：需要合并 [1,2,3] 和 [2,5,6] 。 合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。 示例 2：
输入：nums1 = [1], m = 1, nums2 = [], n = 0 输出：[1] 解释：需要合并 [1] 和 [] 。 合并结果是 [1] 。 示例 3：
输入：nums1 = [0], m = 0, nums2 = [1], n = 1 输出：[1] 解释：需要合并的数组是 [] 和 [1] 。 合并结果是 [1] 。 注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。
提示：
nums1.length == m + n nums2.length == n 0 <= m, n <= 200 1 <= m + n <= 200 -109 <= nums1[i], nums2[j] <= 109
来源：力扣（LeetCode） 链接：leetcode.cn/problems/me… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
- 典型的双指针,先找第一个，再找第二个，依次循环，空间上多用了m+n的数组，可以直接用num1的数组
public void merge(int[] nums1, int m, int[] nums2, int n) {
// 双指针
int[] temp = new int[m + n];
for (int i=0,nums1Index=0,nums2Index = 0;i<m+n;i++){
if (nums1Index>=m){
temp[i] = nums2[nums2Index++];
}else if (nums2Index>=n){
temp[i] = nums1[nums1Index++];
}else if (nums1[nums1Index]<nums2[nums2Index]){
temp[i] = nums1[nums1Index++];
}else {
temp[i] = nums2[nums2Index++];
}
}
for (int i = 0; i < nums1.length; i++) {
nums1[i] = temp[i];
}
}
不使用临时数组 需要从后往前遍历
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int index = m + n - 1;
int nums2Index = n - 1;
int nums1Index = m - 1;
for (int i = index; i >= 0; i--) {
if (nums2Index < 0) {
nums1[i] = nums1[nums1Index--];
} else if (nums1Index < 0) {
nums1[i] = nums2[nums2Index--];
} else if (nums1[nums1Index] > nums2[nums2Index]) {
nums1[i] = nums1[nums1Index--];
} else {
nums1[i] = nums2[nums2Index--];
}
}
}
}
283
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12] 输出: [1,3,12,0,0] 示例 2:
输入: nums = [0] 输出: [0]
提示:
1 <= nums.length <= 104 -231 <= nums[i] <= 231 - 1
来源：力扣（LeetCode） 链接：leetcode.cn/problems/mo… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
首先遍历一遍，把非0的元素放在前面，记录还剩多少，然后再将剩下的元素全部置为0
class Solution {
public void moveZeroes(int[] nums) {
if(nums==null){
return;
}
int j = 0;
for(int i = 0;i<nums.length;i++){
if(nums[i]!=0){
nums[j++]=nums[i];
}
}
for(int i = j;i<nums.length;i++){
nums[i] = 0;
}
}
}
448
给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。
示例 1：
输入：nums = [4,3,2,7,8,2,3,1] 输出：[5,6] 示例 2：
输入：nums = [1,1] 输出：[2]
提示：
n == nums.length 1 <= n <= 105 1 <= nums[i] <= n 进阶：你能在不使用额外空间且时间复杂度为 O(n) 的情况下解决这个问题吗? 你可以假定返回的数组不算在额外空间内。
来源：力扣（LeetCode） 链接：leetcode.cn/problems/fi… 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
思路
1.用额外空间比较简单，只需要一个hashSet 然后判断就可以了 代码如下
class Solution {
public List<Integer> findDisappearedNumbers(int[] nums) {
List<Integer> list = new ArrayList<Integer>();
Set<Integer> set = new HashSet<Integer>();
for(int i = 0;i<nums.length;i++){
set.add(nums[i]);
}
for(int i = 1;i<=nums.length;i++){
if(!set.contains(i)){
list.add(i);
}
}
return list;
}
}
如果不使用额外空间呢，我看了题解，真的是有点秒
- 首先，是从1-n 这个数组，肯定有数字是重复的。
- 然后我们先找对应的下标，然后给对应的下标+n，这个时候，因为有数字是重复的，相当于有的下标永远取不到，意味着<=n的数字，就是我们要取的
class Solution {
public List<Integer> findDisappearedNumbers(int[] nums) {
List<Integer> list = new ArrayList<Integer>();
int length = nums.length;
for(int num:nums){
// 取下标
int index = (num-1)%length;
// 给对应的下标加值
nums[index] = nums[index]+length;
}
for(int i =0; i<length;i++){
if(nums[i]<=length){
list.add(i+1);
}
}
return list;
}
}
