Leetcode 1.两数之和(C++)

普通做法：暴力

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int size=nums.size(), flag=0;;
        vector<int> vec(2);
        for(int i=0; i<size && flag==0; i++){
            for(int j=i+1; j<size && flag==0; j++){
                if(nums[j]==target-nums[i]){
                    vec[0]=i;
                    vec[1]=j;
                    flag=1;
                }
            }
        }
        return vec;
    }
};

时间复杂度是O(n^2)
空间复杂度是O(1)

两遍hash解法

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> dm;
        int size=nums.size();

        for(int i=0; i<size; i++)
            dm[nums[i]]=i;

        for(int i=0; i<size; i++){
            if(dm.find(target-nums[i])!=dm.end() && dm[target-nums[i]]!=i)
                return {i, dm[target-nums[i]]};	//返回集合的小技巧
        }
        return {};
    }
};

一遍hash解法

//一遍hash可以考虑到一个键多个值的情况，比如：[2, 2], target:4
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> dm;
        int size=nums.size();

        for(int i=0; i<size; i++){
            if(dm.find(target-nums[i])!=dm.end())
                return {dm[target-nums[i]], i};
            dm[nums[i]]=i;
        }
        return {};
    }
};

hashmap原理浅析：

1. hashmap底层是由于数组和链表共同实现的

2. 存数据：先将key值转化为哈希地址，如果该地址已经被占用，就将节点直接链上去，时间复杂度为O(1);

   取数据：先将key值转化为哈希地址，通过哈希地址找到链表，如果链表只有一个节点或者要找的就是头节点，就得到了最好情况下的时间复杂度O(1)；如果要找的在链表的后边，就要一个节点一个节点向后查找，得到最坏时间复杂度为O(n)

3. hashmap默认存放进去是无序的，但是无法存放一个键对应的多个值

如果此题要返回的不是位置，而是值，则有如下解法：

1. 将该数组进行排序
2. 用两个指针一个指向数组的最小值，另一个指向第一个大于等于target的值。
3. 两个指针所指向的值相加，如果总和大于taget，则将右边的指针向左移，如果小于target，则将左边的指针向右移
4. 重复步骤三直至找到解