两数之和

nums = [6, 4, 2, 9]

target = 10

return 4 and 6

---

思路1 暴力解法

public int[] twoSum(int[] numbers, int target) {
	if (numbers == null) {
		return new int[]{};
	}

	for (int left=0; left<numbers.length; left++) {
		int right=numbers.length-1;
		while (left < right && (numbers[left] + numbers[right]) != target){
			right--;
		}

		if ((numbers[left] + numbers[right]) == target ) {
			return new int[] {left, right};
		}
		
	}

	return new int[]{};
}

思路2 哈希表

哈希表不作为输入也不作为输出

时间复杂度：O(n)

空间复杂度：O(n)

public int[] twoSum(int[] numbers, int target) {
	if (numbers.length == 0) {
		return new int[]{-1, -1};
	}
	Map<Integer, Integer> hashTable = new HashMap<Integer, Integer>();
	
	for (int i = 0; i < numbers.length; i++) {
		hashTable.put(numbers[i], i);
	}
	
	for (int i = 0; i < numbers.length; i++) {
		if (hashTable.containsKey(target - numbers[i])) {
		    int index1 = Math.min(i, hashTable.get(target - numbers[i]));
		    int index2 = Math.max(i, hashTable.get(target - numbers[i]));
			return new int[]{index1, index2};
		}
	}
	
	return new int[]{-1, -1};
}

思路3 双指针

先排序后查找

时间复杂度：O(nlogn)

空间复杂度：O(1)

input: [6, 4, 2, 9], target = 10

sort:   [2, 4, 6, 9]  f(L) + f(R) ? target               [2, 4, 6, 9]  f(L) + f(R) ? target            [2, 4, 6, 9]  f(L) + f(R) ? target

           ^           ^      2 + 9 = 11 > 10      ==>     ^       ^       2 + 6 = 8 < 10         ==>        ^   ^       4 + 6 = 10 = 10      ==> 4, 6

           L           R                                               L      R

---

input: [6, 5, 2, 9], target = 10

sort:   [2, 5, 6, 9]  f(L) + f(R) ? target               [2, 5, 6, 9]  f(L) + f(R) ? target            [2, 5, 6, 9]  f(L) + f(R) ? target          [2, 5, 6, 9]

           ^           ^      2 + 9 = 11 > 10      ==>     ^       ^       2 + 6 = 8 < 10         ==>        ^   ^       5 + 6 = 11 > 10      ==>       ^^          ==>指针重叠，结束        

           L           R                                               L      R                                                                                                            LR

class Pair implements Comrable<Pair> {
	int count, index;
	
	public Pair(int count, int index) {
		this.count = count;
		this.index = index;
	}
	
	public int compareTo(Pair other) {
		return count = other.number;
	}
}

public int[] towSum(int[] nums, int target) {
	int[] result = {-1, -1};
	
	if (nums == null) {
		return result;
	}
	
	Pair[] pairs = getSortedPairs(count);
	
	int left = 0, right = pairs.length - 1;
	while (left < right) {
		if (pairs[left].count + pairs[right].number < target) {
			left++:
		} else if (pairs[left].count + pairs[right].number > target) {
			right--;
		} else {
			result[0] = Math.min(pairs[left].index, pairs[right].index);
			result[1] = Math.max(pairs[left].index, pairs[right].index);
			return result;
		}
	}
	
	return result;
}

public Pair[] getSortedPairs(int[] nums) {
	Pair pairs = new Pair[nums.length];
	for (int i = 0; i < nums.length; i++) {
		pairs[i] = new Pair(nums[i], i);
	}
	Arrays.sort(pairs);
	
	return pairs;
}