Two Sum

最新推荐文章于 2025-12-28 17:52:30 发布

原创最新推荐文章于 2025-12-28 17:52:30 发布 · 304 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #twosum

leetcode 专栏收录该内容

1 篇文章

订阅专栏

本文介绍了一种高效解决寻找数组中和为目标数的两个元素的问题的方法，包括了时间复杂度O(n)，空间复杂度O(1)的两层循环方法，时间复杂度O(n)，空间复杂度O(n)的HashMap方法，以及时间复杂度O(nlogn)，空间复杂度O(n)的排序方法。重点介绍了如何通过不同方法优化查找效率。

题目：

Given an array of integers, 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.

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

****************

1.两层循环,时间复杂度O(n2),空间复杂度O(1)

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int[] rsltIndices = { -1, -1 };// Not found,index is -1
		for (int i = 0; i < numbers.length - 1; i++) {
			for (int j = i + 1; j < numbers.length; j++) {
				if (numbers[i] + numbers[j] == target) {
					rsltIndices[0] = i + 1;
					rsltIndices[1] = j + 1;
					return rsltIndices;
				}
			}
		}
		return rsltIndices;
    }
}

2.使用HashMap,时间复杂度O(n),空间复杂度O(n)

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
      	int[] rsltIndices = new int[2];
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		for (int i = 0; i < numbers.length; i++) {
			if (map.containsKey(target - numbers[i])) {
				rsltIndices[0] = map.get(target - numbers[i]) + 1;
				rsltIndices[1] = i + 1;
				break;
			} else {
				map.put(numbers[i], i);
			}
		}
		return rsltIndices;
    }
}

3.使用新数组排序,时间复杂度O(nlogn),空间复杂度O(n)

public class Solution {
    public int[] twoSum(int[] numbers, int target) {
      	int N = numbers.length;
		int[] sortedArr = new int[N];
		System.arraycopy(numbers, 0, sortedArr, 0, N);
		Arrays.sort(sortedArr);
		int firstIndex = 0;
		int lastIndex = N - 1;
		while (firstIndex < lastIndex) {
			if (sortedArr[firstIndex] + sortedArr[lastIndex] < target) {
				firstIndex++;
			} else if (sortedArr[firstIndex] + sortedArr[lastIndex] > target) {
				lastIndex--;
			} else {
				break;
			}
		}
		int firstNum = sortedArr[firstIndex];
		int lastNum = sortedArr[lastIndex];
		firstIndex = -1;
		lastIndex = -1;
		for (int i = 0; i < N; i++) {
			if (numbers[i] == firstNum || numbers[i] == lastNum) {
				if (firstIndex == -1) {
					firstIndex = i + 1;
				} else {
					lastIndex = i + 1;
				}
			}
		}
		int[] rslt = new int[2];
		rslt[0] = firstIndex < lastIndex ? firstIndex : lastIndex;
		rslt[1] = firstIndex > lastIndex ? firstIndex : lastIndex;
		return rslt;
    }
}