leetcode 2Sum、3Sum、3sum closet、Two Sum II - Input array is sorted、Two Sum IV

1.two sum---leetcode1

用hash直接解决，hash的索引存储数值，内部存储index坐标

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> result;
        unordered_map<int,int> hash;
        int length = nums.size();
        for(int i = 0;i < length;i++){
            int find_num = target - nums[i];
            if(hash.find(find_num) != hash.end()){
                result.push_back(hash[find_num]);
                result.push_back(i);
                return result;
            }
            hash[nums[i]] = i;
        }
        return result;
    }
};

2. 3 sum---leetcode 15

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        std::sort(nums.begin(),nums.end());
        for(int i = 0;i < nums.size();i++){
            int target = 0 - nums[i];
            int first = i+1;
            int end = nums.size() - 1;
            while(first < end){
                if(nums[first] + nums[end] == target){
                    vector<int> res;
                    int num1 = nums[first];
                    int num2 = nums[end];
                    res.push_back(nums[i]);
                    res.push_back(num1);
                    res.push_back(num2);
                    result.push_back(res);
                    while(first < end && nums[first] == num1)
                        first++;　　　　　　　　　　　　　　　　　　　　相同的数字过滤掉
                    while(first < end && nums[end] == num2)
                        end--;　　　　　　　　　　　　　　　　　　　　　相同的数字过滤掉
                }
                else if(nums[first] + nums[end] < target)
                    first++;
                else
                    end--;
            }
            while (i + 1 < nums.size() && nums[i + 1] == nums[i]) 
                i++;　　　　　　　　　　　　　　　　　　　　　　　　　　　 相同的数字过滤掉
        }
        return result;
    }
};

3.3Sum closest

https://blog.csdn.net/shanshanhi/article/details/58615537

跟3sum的思路几乎一致，只是需要更新一个min_gap

class Solution {
public:
    int threeSumClosest(vector<int>& nums, int target) {
        int length = nums.size();
        sort(nums.begin(),nums.end());
        int min_gap = target - nums[0] - nums[1] - nums[2];
        for(int i = 0;i < length;i++){
            int start = i + 1;
            int end = length - 1;
            while(start < end){
                int gap = target - nums[i] - nums[start] - nums[end];
                if(abs(gap) < abs(min_gap))
                    min_gap = gap;
                if(gap == 0)
                    return target;
                else if(gap < 0)
                    end--;
                else
                    start++;
            }
        }
        return target - min_gap;
    }
};

4.Two Sum II - Input array is sorted

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        vector<int> result;
        int start = 0;
        int end = numbers.size() - 1;
        while(start < end){
            int sum = numbers[start] + numbers[end];
            if(sum == target){
                result.push_back(start+1);
                result.push_back(end+1);
                start++;
                end--;
            }
            else if (sum < target)
                start++;
            else
                end--;
        }
        return result;
    }
};

5.Two Sum IV - Input is a BST

类似于two sum用hash做：

class Solution {
public:
    bool findTarget(TreeNode* root, int k) {
        if(root == NULL)
            return false;
        unordered_set<int> flag;
        return findCore(root,k,flag);
    }
    bool findCore(TreeNode* root,int k,unordered_set<int>& flag){
        if(root == NULL)
            return false;
        if(flag.find(k - root->val) != flag.end())
            return true;
        flag.insert(root->val);
        return findCore(root->left,k,flag) || findCore(root->right,k,flag);
    }
};