1. 两数之和（简单）

题目链接

问题：

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

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

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

通过次数1,348,299
提交次数2,732,584

思路：

①双指针扫描法（O(n)）：一个头指针一个尾指针，令头尾指针指的数相加，小了头指针后移，大了尾指针前移（即杨式矩阵的思维方式）.
***** 杨式矩阵（n*m）：行和列都是递增的.
***** 查找某值x：从右上角（本行最大，本列最小，或者左下角-本列最大，本行最小）那个数字开始，小了向下走，大了向左走，最多走n+m步，时间复杂度O(n+m).
②二分法（O(nlogn)）：前提是数据有序. 设置一个头指针p，排序后按序指向某个数x，用二分查找target-x，若找到就返回这两个数的下标，否则p后移继续查找.
③哈希表（O(n)）：unordered_map基于哈希表不保证数据有序性，map基于红黑树会保证数据有序性，哈希表无论数据有序无序都能用，维护的是当前位置之前的集合.

/* 双指针扫描法 */
#include <vector>
using namespace std;

class Solution {
    public:
        typedef pair<int, int> PII;
        vector<int> twoSum(vector<int>& nums, int target) {
            vector<PII> vec;
            for(int i=0; i<nums.size(); i++) {
                vec.push_back(PII(nums[i], i));
            }
            sort(vec.begin(), vec.end());
            int p=0, q=vec.size()-1;
            while(1) {
                int a=vec[p].first;
                int b=vec[q].first;
                if(a+b==target) break;
                if(a+b<target) p++;
                else q--; 
            }
            int a=vec[p].second;
            int b=vec[q].second;
            if(a>b) swap(a, b);
            vector<int> ret;
            ret.push_back(a);
            ret.push_back(b);
            return ret;
        }
}; 

/* 二分法 */
#include <vector>
using namespace std;

class Solution {
public:
    typedef pair<int, int> PII;
    int my_binary_search(vector<PII> &vec, int L, int x) {
        int R=vec.size()-1, mid;
        while(L<=R) {
            mid=(L+R)>>1;
            if(vec[mid].first==x) return vec[mid].second;
            if(vec[mid].first<x) L=mid+1;
            else R=mid-1;
        }
        return -1;
    }
    
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<PII> vec;
        vector<int> ret;
        for(int i=0; i<nums.size(); i++) {
            vec.push_back(PII(nums[i], i));
        }
        sort(vec.begin(), vec.end());
        for(int i=0; i<vec.size(); i++) {
            int id1=vec[i].second;
            int id2=my_binary_search(vec, i+1, target-vec[i].first);
            if(id2==-1) continue;
            if(id1>id2) swap(id1, id2);
            ret.push_back(id1);
            ret.push_back(id2);
            break;
        }
        return ret;
    }
};

/* 哈希表 */
#include <vector>
#include <unordered_map>
using namespace std;

class Solution {
public:
    typedef pair<int, int> PII;
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ret;
        unordered_map<int, int> ha;
        for(int i=0; i<nums.size(); i++) {
            int val=target-nums[i];
            if(ha.find(val)==ha.end()) {
                ha[nums[i]]=i;
            }else {
                ret.push_back(ha[val]);
                ret.push_back(i);
                break;
            }
        }
        return ret;
    }
};

纪念在力扣刷的第一题——这里要感谢一下船长，虽然我不是船员.