Java 二和二-输入数组已排序

Leetcode#167几乎与#1相同，但为什么我不能只添加if条件呢

问：给定一个已按升序排序的整数数组，找到两个数字，使它们相加为一个特定的目标数字

函数twoSum应该返回两个数字的索引，以便它们相加到目标，其中index1必须小于index2

注:

您返回的答案（index1和index2）不是基于零的。 您可以假设每个输入都有一个解决方案，并且不能使用同一个元素两次

例如： 输入：数字=[2,7,11,15]，目标=9 输出：[1,2]

The sum of 2 and 7 is 9. 
Therefore index1 = 1, index2 = 2.

我的代码：

class Solution {
public int[] twoSum(int[] numbers, int target) {
        for (int i = 1; i < numbers.length; i++) {
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[j] == target - numbers[i]) {
                    if(numbers[i] < numbers[j])
                        return new int[] { i, j };
        }
    }
}
 return null;
}

类解决方案{
公共int[]twoSum（int[]数字，int目标）{
对于（int i=1；i

}

---

为什么我总是返回null？我的错在哪里？如何修复它？

因为在java中，问题是数组从1开始并不意味着数组从1开始。如果你想返回i，j作为非零，你应该从1到长度+1，然后在条件内检查索引i-1，j-1，或者从0开始返回i+1，j+1

class Solution {
  public int[] twoSum(int[] numbers, int target) {
    for (int i = 1; i < numbers.length+1; i++) {
        for (int j = i + 1; j < numbers.length+1; j++) {
            if (numbers[j-1] == target - numbers[i-1]) {
                if(numbers[i-1] < numbers[j-1])
                    return new int[] { i, j };
            }
        }
    }
     return null;
  }
 }

类解决方案{
公共int[]twoSum（int[]数字，int目标）{
对于（int i=1；i

或者你可以

    class Solution {
  public int[] twoSum(int[] numbers, int target) {
    for (int i = 0; i < numbers.length; i++) {
        for (int j = i + 1; j < numbers.length; j++) {
            if (numbers[j] == target - numbers[i]) {
                if(numbers[i] < numbers[j])
                    return new int[] { i+1, j+1 };
            }
        }
    }
     return null;
  }
 }

类解决方案{
公共int[]twoSum（int[]数字，int目标）{
for（int i=0；i

我已修改了您的代码，并添加了代码注释，说明您以前的代码出现错误的原因。有关详细信息，请参阅下面的代码

public class Main {

    public static void main(String[] args) {
        int target = 9;
        int[] numbers = new int[] { 2, 7, 11, 15 };
        int[] result = twoSum(numbers, target);
        if (result != null) {
            System.out
                    .println("The sum of " + numbers[result[0]] + " and " + numbers[result[1]] + " is " + target + ".");
            System.out.println("Therefore index1 = " + (result[0] + 1) + ", index2 = " + (result[1] + 1));
        } else {
            System.out.println("No Solution found!");
        }
    }

    public static int[] twoSum(int[] numbers, int target) {
        for (int i = 0; i < numbers.length; i++) { // array index starts at 0
            for (int j = i + 1; j < numbers.length; j++) {
                if (numbers[j] + numbers[i] == target) { // add the current numbers
                    // if (numbers[i] < numbers[j]) // not needed
                    return new int[] { i, j };
                }
            }
        }
        return null;
    }

}

样本输出：

The sum of 2 and 7 is 9.
Therefore index1 = 1, index2 = 2

---

您首先使用

i=0

启动循环

，您应该使用
i=1
启动循环

工作代码：

public class Solution 
{
    public static void main(String[] args)
    {
        int[] num = {2,7,11,5};
        int n = 13;
        int[] answer = new int[2];
        answer = twoSum(num,n);
        if(answer != null)
            for(int i=0;i<2;i++)
                System.out.printf( answer[i] +" ");
    }


    public static int[] twoSum(int[] numbers, int target)
    {
        for (int i = 0; i < numbers.length; i++) 
        {
            for (int j = i + 1; j < numbers.length; j++) 
            {
                if (numbers[j] == target - numbers[i]) 
                {
                    if(numbers[i] < numbers[j])
                        return new int[] { i+1, j+1};
                }
            }
        }
        return null;
    }
}

公共类解决方案
{
公共静态void main（字符串[]args）
{
int[]num={2,7,11,5}；
int n=13；
int[]答案=新的int[2]；
答案=twoSum（num，n）；
如果（回答！=null）
对于（int i=0；i这是一个更好的解决方案，因为它速度更快，并且涵盖了所有测试用例：

class Solution {
public int[] twoSum(int[] numbers, int target) {
    int l = 0, r = numbers.length - 1;
    while (numbers[l] + numbers[r] != target) {
        if (numbers[l] + numbers[r] > target) 
            r--;
        else 
            l++;
        if (r == l) return new int[]{};
    }
    return new int[]{l + 1, r + 1};
  }
}


[问题]：167.二和二-输入数组排序

使用双指针技术：-

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        if (numbers == null || numbers.length == 0)
            return null;
        int i = 0;
        int j = numbers.length - 1;
        while (i < j) {
            int x = numbers[i] + numbers[j];
            if (x < target) {
                ++i;
            } else if (x > target) {
                j--;
            } else {
                return new int[] { i + 1, j + 1 };
            }
        }
        return null;
    }
}

类解决方案{
公共int[]twoSum（int[]数字，int目标）{
if（numbers==null | | numbers.length==0）
返回null；
int i=0；
int j=数字。长度-1；
而（i目标），则执行其他操作{
j--；
}否则{
返回新的int[]{i+1，j+1}；
}
}
返回null；
}
}
数组索引以
0
0开始，而不是
1
one-check循环开始值；（仅为了可读性
number[i]+number[j]==target
将是更自然的检查，因为它类似于所请求的内容）我不知道。你应该学会调试你的代码。为什么你从
I=1
开始循环，而不是从
I=0
？仅仅因为预期的输出不是基于零的，并不意味着输入也不是。你的目标是9，你从索引1循环数组，所以它从7开始，然后尝试添加下一个索引值，所以你r未获得所需的输出。如果从0开始循环，则第0个索引的值为2，第1个索引的值为7，则将获得所需的输出。请在问题中添加标记。
class Solution {
    public int[] twoSum(int[] numbers, int target) {
        if (numbers == null || numbers.length == 0)
            return null;
        int i = 0;
        int j = numbers.length - 1;
        while (i < j) {
            int x = numbers[i] + numbers[j];
            if (x < target) {
                ++i;
            } else if (x > target) {
                j--;
            } else {
                return new int[] { i + 1, j + 1 };
            }
        }
        return null;
    }
}