1. 两数之和
给定一个整数数组 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(n^2) 的算法吗?
方法一:暴力枚举
最容易想到的方法是枚举数组中的每一个数 x,寻找数组中是否存在 target - x。
当我们使用遍历整个数组的方式寻找 target - x 时,需要注意到每一个位于 x 之前的元素都已经和 x 匹配过,因此不需要再进行匹配。而每一个元素不能被使用两次,所以我们只需要在 x 后面的元素中寻找 target - x。
代码
class Solution {
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (nums[i] + nums[j] == target) {
return new int[]{i, j};
}
}
}
return new int[0];
}
}
复杂度分析
时间复杂度:O(N^2),其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
空间复杂度:O(1)。
方法二:哈希表
创建一个HashMap,默认为空,遍历数组nums,对元素nums[i]进行如下处理:
如果target-nums[i]的值在HashMap中存在映射关系(使用containsKey方法),则找到了满足题目条件的答案————target-nums[i]对应的索引,以及索引i;如果不存在,则以nums[i]为键,其索引i为值,放入HashMap。
注意:nums数组中的元素充当key,其索引充当value,由于在Map集合的映射关系中,key是唯一的,value是可重复的(即不同key可以对应相同的value,但key要求互不相同,故允许根据key取value,不允许根据value取其key),所以这样做便于根据值target-nums[i]取其索引,这道题索引是我们想要的答案。
代码
class Solution {
public int[] twoSum(int[] nums, int target) {
int[] res = {0,0};//用于存放答案的数组
HashMap<Integer,Integer> hm = new HashMap<>();
//nums[i]充当key,索引i充当value
for (int i = 0; i < nums.length; i++) {
if (hm.containsKey(target - nums[i])) {
//找到答案了
res[0] = hm.get(target - nums[i]);
res[1] = i;
break;
}
else{
hm.put(nums[i],i);
}
}
return res;
}
}
复杂度分析
时间复杂度:O(N),其中 N是数组中的元素数量。对于每一个元素 x,我们可以 O(1) 地寻找 target - x。
空间复杂度:O(N),其中 N 是数组中的元素数量。主要为哈希表的开销。
88. 合并两个有序数组
给你两个按 非递减顺序 排列的整数数组 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] 。示例 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
进阶:你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗?
方法一:直接合并后排序
最直观的方法是先将数组nums 2 放进数组 nums 1的尾部,然后直接对整个数组进行排序。
代码
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
//将nums2数组中从索引为0开始长度为n的数据复制到nums1中,并从nums1索引为m开始。
System.arraycopy(nums2,0,nums1,m,n);
Arrays.sort(nums1);
}
}
复杂度分析
时间复杂度:O((m+n)log(m+n))。
排序序列长度为 m+n,套用快速排序的时间复杂度即可,平均情况为 O((m+n)log(m+n))。
空间复杂度:O(1))。
除了nums1和nums2,没用到其他数组。
方法二:双指针
为了利用数组 nums 1与 nums 2已经被排序的这一性质,我们可以使用双指针方法。这一方法将两个数组看作队列,每次从两个数组头部取出比较小的数字放到结果中。
代码
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int p1 = 0, p2 = 0; //双指针初始位置
int[] sorted = new int[m + n]; //新的数组存放m+n个有序数
int cur; //当前指针所在位置的数
//只要双指针还没走完
while (p1 < m || p2 < n) {
if (p1 == m) { // p2 < n
//如果nums1索引走完了,就把走到的nums2的数插入到新数组中
cur = nums2[p2++];
} else if (p2 == n) { // p1 < m
//反之,就把nums1的数插入到新数组中
cur = nums1[p1++];
} else if (nums1[p1] < nums2[p2]) {
//如果nums2中的数更大,就把nums1中较小的数插入新数组中
cur = nums1[p1++];
} else {
//反之,就把nums2中较小的数插入新数组中
cur = nums2[p2++];
}
sorted[p1 + p2 - 1] = cur;
}
for (int i = 0; i != m + n; ++i) {
nums1[i] = sorted[i]; //再把新数组中的数赋给nums1
}
}
}
复杂度分析
时间复杂度:O(m+n)。
指针移动单调递增,最多移动 m+n 次,因此时间复杂度为 O(m+n)。
空间复杂度:O(m+n)。
需要建立长度为 m+n 的中间数组 sorted。
方法三:逆向双指针
指针设置为从后向前遍历,每次取两者之中的较大者放进nums 1 的最后面,省去了
代码
class Solution {
public void merge(int[] nums1, int m, int[] nums2, int n) {
int p1 = m - 1, p2 = n - 1;
int tail = m + n - 1;
int cur;
while (p1 >= 0 || p2 >= 0) {
if (p1 == -1) {
cur = nums2[p2--];
} else if (p2 == -1) {
cur = nums1[p1--];
} else if (nums1[p1] > nums2[p2]) {
cur = nums1[p1--];
} else {
cur = nums2[p2--];
}
nums1[tail--] = cur;
}
}
}
复杂度分析
时间复杂度:O(m+n)。
指针移动单调递减,最多移动 m+n 次,因此时间复杂度为 O(m+n)。
空间复杂度:O(1)。
直接对数组 nums1原地修改,不需要额外空间。