# Leetcode 167. Two Sum II – Input array is sorted Screenshot
from 2016-03-01 21:28:37.png

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
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

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.

# 1.描述

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
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

My code:

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
zero-based.

# 2.分析

``````public class Solution { public int[] twoSum(int[] numbers, int target) { if (numbers == null || numbers.length < 2) return null; HashMap<Integer, Integer> tracker = new HashMap<Integer, Integer>(); for (int i = 0; i < numbers.length; i++) { if (tracker.containsKey(numbers[i])) { int[] ret = new int; ret = tracker.get(numbers[i]) + 1; ret = i + 1; return ret; } else { tracker.put(target - numbers[i], i); } } return null; }}
``````
``````public int[] twoSum(int[] numbers, int target) {
int[] res = new int;
if (numbers == null || numbers.length < 2) {
return new int;
}

int left = 0, right = numbers.length - 1;
while (left < right) {
if (numbers[left] + numbers[right] == target) {
res = left + 1;
res = right + 1;
return res;
} else if (numbers[left] + numbers[right] > target) {
right--;
} else {
left++;
}
}

return res;
}
``````

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

# 3.代码

``````/**
* Return an array of size *returnSize.
* Note: The returned array must be malloced, assume caller calls free().
*/
int* twoSum(int* numbers, int numbersSize, int target, int* returnSize) {
if (NULL == numbers || numbersSize < 2) return NULL;
unsigned int index1 = 0;
unsigned int index2 = numbersSize - 1;
while (index1 < index2) {
while (index1 < index2 && numbers[index1] + numbers[index2] < target) ++index1;
while (index1 < index2 && numbers[index1] + numbers[index2] > target) --index2;
if (numbers[index1] + numbers[index2] == target) {
*returnSize = 2;
int* returnNums = (int*)malloc((*returnSize)*sizeof(int));
returnNums = index1 + 1;
returnNums = index2 + 1;
return returnNums;
}
}
return NULL;
}
``````

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

Anyway, Good luck, Richardo!

# 分析

``````/**
* Return an array of size *returnSize.
* Note: The returned array must be malloced, assume caller calls free().
*/
int* twoSum(int* numbers, int numbersSize, int target, int* returnSize) {
while(index1<index2)
{
if(numbers[index1]+numbers[index2]==target)
break;
else if(numbers[index1]+numbers[index2]<target)
{
index1++;
}
else
index2--;
}
int *ans=(int*)malloc(sizeof(int)*2);
ans=index1+1;
ans=index2+1;
*returnSize=2;
return ans;
}
``````

My code:

``````public class Solution { public int[] twoSum(int[] numbers, int target) { if (numbers == null || numbers.length == 0) { return null; } int begin = 0; int end = numbers.length - 1; while (begin < end) { int sum = numbers[begin] + numbers[end]; if (sum > target) { end--; } else if (sum < target) { begin++; } else { int[] ret = new int; ret = begin + 1; ret = end + 1; return ret; } } return null; }}
``````

reference:

Anyway, Good luck, Richardo! — 09/02/2016