题目
给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
提示
进阶:你可以想出一个时间复杂度小于 O(n2)
的算法吗?
解法1
梦开始的地方,如果在一个整数数组中需要找到两个值的之和等于整数目标值 ,可以直接遍历暴力查询,代码如下:
class leetcode0001 {
public:
vector<int> twoSum(vector<int>& nums, int target) {
for (int i = 0; i < nums.size(); ++i) {
for (int j = i + 1; j < nums.size(); ++j) {
if (nums[i] + nums[j] == target) {
return {i, j};
}
}
}
return {};
}
};
时间复杂度为O(n^2),空间复杂度为O(1),执行结果如下:
但是提示信息中说需要想出一个时间复杂度小于 O(n2)
的算法,那么遍历枚举肯定不行了。
解法2
回到原点,无论如何第一次遍历循环必须的,那么能否减少第二次遍历循环的时间呢?这个时候可以通过哈希表来实现,将这部分时间优化为O(1),但是为了保存该部分数据,需要通过额外的空间保存数据,空间复杂度为O(n)。代码如下:
class leetcode0001 {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> buffer{};
for (int i = 0; i < nums.size(); ++i) {
auto it = buffer.find(target - nums[i]);
if (it != buffer.end()) {
return {it->second, i};
}
buffer[nums[i]] = i;
}
return {};
}
};
时间复杂度为O(n),空间复杂度为O(n),执行结果如下:
可以发现,解法2比解法1快了约290ms,两者不在同一个数量级上。
解法3
该解法是参考了双指针法,通过对输入数据进行缓存并且排序,这样可以快速查询到满足结果为目标值 target 的那两个整数,然后在原数据集合中查询该两个整数对应的索引即可。
class leetcode0001 {
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> temp(nums);
sort(temp.begin(), temp.end()); \\ 排序,时间复杂度为O(nlogn)
int left = 0;
int right = temp.size() - 1;
while (left < right) {
auto result = temp[left] + temp[right];
if (result == target) {
break; // 如果结果和等于目标值,退出循环
} else if (result < target) {
++left; // 如果结果和小于目标值,增大左边界索引
} else {
--right; // 如果结果和大于目标值,减小右边界索引
}
}
if (left >= right) {
return {}; // 该分支为未查询到结果的情况,直接返回空集
}
vector<int> result{0, 0};
int size = nums.size();
for (int i = 0; i < size; ++i) {
if ((left != size) && (nums[i] == temp[left])) {
result[0] = i;
left = size;
continue;
}
if ((right != size) && (nums[i] == temp[right])) {
result[1] = i;
right = size;
continue;
}
if ((left == size) && (right == size)) {
return result;
}
}
return result;
}
};
时间复杂度为O(nlogn),空间复杂度为O(n)。执行结果如下:
解法3与解法2相比较而言,空间复杂度虽然一致,但是比哈希表耗费的空间更小。