Question

我正在处理leetcode问题。我刚刚解决了以下问题：

给定一个整数数组，找到两个数字，使它们相加到一个特定的目标数。

函数twoSum应返回两个数字的索引，以便它们相加到目标，其中index1必须小于index2。请注意，您返回的答案（index1和index2）不是从零开始的。

您可以假设每个输入都只有一个解决方案。

输入：数字= {2,7,11,15}，目标= 9 输出：index1 = 1，index2 = 2

我的代码在这里：

public class Solution {
    public int[] twoSum(int[] numbers, int target) {

            int len = numbers.length;

        int[] result = new int[2] ;
        int number1 = 0;
        int sum = 0;

        for (int i = 0; i < len; i++) {
            number1 = numbers[i];

            for(int j = i+1; j < len; j++)
            {

                sum = number1+numbers[j];       
                if(sum == target)
                {
                    result[0]=i;
                    result[1]=j;
                }
            }

        }
        return result;
    }
}

它给了我超时的时间;但是，我认为这个解决方案可能有效。谁能告诉我这个解决方案是否足够好？先谢谢

Answer 1

这可能会减少时间问题，但我不能保证它会完全解决问题！

您可以在找到解决方案return后立即result，因为问题中说明了针对给定问题确切存在一种解决方案，即

if(sum == target)
{
    result[0]=i;
    result[1]=j;
    return result;
}

而不是继续搜索其余的输入。

Answer 2

public int[] twoSum(int[] nums, int target) { int[] 索引 = 新的 int[2];

    for(int x = 0; x < nums.length ; x++){
        for(int y = 0; y < nums.length ; y++){
            if(x != y && nums[x] + nums[y] == target){
            indices[0] = x;
            indices[1] = y;
            return indices;
        }
        }
    }
    return indices;
}

}

Answer 3

那是因为您的解决方案的时间复杂度为 O(n*n)。这个问题可以用 O(n) 时间复杂度解决，如果你使用 Map

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

来自leetcode的两个Java总和

3 个答案: