1.两数之和

题目链接

暴力

直接利用双重循环找到当前值和数组中另一个值是否相加等于target
时间复杂度O(n²)

class Solution {
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\(log_n\))

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<pair<int, int>> res;
        for(int i = 0; i < nums.size(); ++ i){
            res.push_back({nums[i], i});
        }

        sort(res.begin(), res.end());
        int l = 0, r = res.size() - 1;
        while(l < r){
            int t = res[l].first + res[r].first;
            if(t == target) return {res[l].second, res[r].second};
            else if(t < target) l ++;
            else r --;
        }

        return {};
    }
};

哈希表

在进行遍历的过程中，记录前面每一个值的对应的下标，在遍历到当前值\(X\)的时候找前面是否出现过\(target - x\)，如果出现了直接返回这一数对即可。
时间复杂度为：O(n)

CPP

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> heap;
        for(int i = 0; i < nums.size(); ++ i){
            int t = target - nums[i];
            if(heap.count(t)) return {heap[t], i};
            heap[nums[i]] = i;
        }

        return {};
    }
};

Java

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        int[] res = new int[2];
        for(int i = 0; i < nums.length; ++ i){
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                res[0] = map.get(temp);
                res[1] = i;
                break;
            }
            map.put(nums[i], i);
        }
        return res;
    }
}