1. Two Sum/[3]167. Two Sum II - Input array is sorted(C++/Java)

注：此博客不再更新，所有最新文章将发表在个人独立博客limengting.site。分享技术，记录生活，欢迎大家关注

1. Two Sum

---

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:
Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Java（2018.3.5）：

class Solution {
    public static int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        Map<Integer, Integer> map = new HashMap<>(); // HashMap<value, index>
        for (int i = 0; i < nums.length; i ++) {
            if (map.containsKey(target - nums[i])) {
	        // 注意：nums[i]是后面的数，target - nums[i]是前面的数，因为nums[i]后面的数还没有被插进HashMap
                result[1] = i;
                result[0] = map.get(target - nums[i]);
                break;
            }
            map.put(nums[i], i);
        }
        return result;
    }
}

C++：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> mapping;
        vector<int> result;
        
        for (int i = 0; i < nums.size(); i++) 
            mapping[nums[i]] = i; // 用一个哈希表存储每个数对应的下标
            
        for (int i = 0; i < nums.size(); i++) {
            const int gap = target - nums[i];
            if (mapping[gap] < nums.size() && mapping[gap] > i) {
                result.push_back(i);
                result.push_back(mapping[gap]);
                break;
            }
        }
        return result;
    }
};

167. Two Sum II - Input array is sorted

---

Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution and you may not use the same element twice.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

C++ :

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        int l = 0;
        int r = numbers.size() -1;
        while (l < r) {
            if (numbers[l] + numbers[r] == target) {
                vector<int> output{l + 1, r + 1};
                return output;
            }
            else if (numbers[l] + numbers[r] > target) r --;
                else l ++; 
        }
    }
};

Java :

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] indices = new int[2];
        if (nums == null || nums.length < 2) 
            return indices;
        
        int left = 0, right = nums.length - 1;
        while (right - left >= 1) {
            if (nums[left] + nums[right] == target) {
                indices[0] = left + 1;
                indices[1] = right + 1;
                break;
            } else if (nums[left] + nums[right] < target) {
                left ++;
            } else right --;
        }
        return indices;
    }
}