小鑫的算法之路：leetcode0001 双数之和

题目

给定一个整数数组 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相比较而言，空间复杂度虽然一致，但是比哈希表耗费的空间更小。