leetcode——1.两数之和

题目

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

你可以按任意顺序返回答案。

题解

一、暴力法：

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

二、map

本题使用map作为哈希表，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下表。

c++中的哈希表有三种类型：

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(logn)	O(logn)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

 std::map和std::multimap的key是有序的。

1、两遍哈希表

哈希表插入insert()

map<int, string> mapStudent;
//方式一
mapStudent.insert(pair<int, string>(1, "student_one"));
//方式二
mapStudent.insert(map<int, string>::value_type (1, "student_one"));   
//方式三
mapStudent[1] =  "student_one";

以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是插入数据不了的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值。

使用count，返回的是被查找元素的个数。如果有，返回1；否则，返回0。注意，map中不存在相同元素，所以返回值只能是1或0。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int, int> n;
        vector<int> res;
        for(int i = 0 ;i < nums.size(); i++){
            n.insert(map<int,int>::value_type(nums[i],i));
        }
        for(int i = 0 ;i < nums.size(); i++){
            //判断是否能找到目标元素且不是本身
            if(n.count(target - nums[i]) > 0 && (n[target - nums[i]] != i)){
                res.push_back(i);
                res.push_back(n[target - nums[i]]);
                break;
            }
        }
        return res;
    }
};

2、一遍哈希表

使用find，返回值是一个迭代器，成功返回迭代器指向要查找的元素，失败返回的迭代器指向end。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> n;
        for(int i=0; i<nums.size(); i++){
            auto iter = n.find(target - nums[i]);
            if(iter != n.end()){
                return {iter->second, i};
            }
            n.insert(pair<int,int>(nums[i],i));
        }
        return {};
    }
};

三、双指针

类似于快速排序。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> n = nums;
        sort(n.begin(),n.end());
        vector<int> res;
        int i=0,j=n.size()-1;
        while(i<j){
            if(n[i]+n[j] == target){
                for(int k=0; k<nums.size(); k++){
                    if(nums[k] == n[i]){
                        res.push_back(k);
                    }
                    else if(nums[k] == n[j]){
                        res.push_back(k);
                    }
                }
                return res;
            }
            else if(n[i]+n[j] > target){
                j--;
            }
            else{
                i++;
            }
        }
        return res;
    }
};