Question

我有一个整数数组.. 我会输入一个数字而且我必须找出两个数字的索引位置，这样数字的总和等于输入数字。

我用以下代码

完成了

import java.io.BufferedInputStream;
import java.util.Arrays;
import java.util.Scanner;

public class FindIndex {

    int a[] = { 1, 7, 6, 5, 12, 2, 3, 11 };

public void findingIndex() {
    Arrays.sort(a);
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter the sum of two selected numbers from the array");
    int i = sc.nextInt();
    for(int j=0;j<a.length;j++){
        for(int k=j+1;k<a.length;k++){
            if(a[j]+a[k]==i){
                System.out.println(Arrays.toString(a));
                System.out.println("The indexes of the elements are"+j+"and"+k);
            }
        }
    }


}

public static void main(String[] args) {
    FindIndex fi = new FindIndex();
    fi.findingIndex();
    System.out.println("end of the program");
}

}

输出

Enter the sum of two selected numbers from the array
14
[1, 2, 3, 5, 6, 7, 11, 12]
The indexes of the elements are1and7
[1, 2, 3, 5, 6, 7, 11, 12]
The indexes of the elements are2and6
end of the program

现在我想只用一个用于循环 来实现这个目标？怎么办？

Answer 1

由于您的数组已经排序，您可以创建两个索引，一个从开始开始，一个从结尾开始。如果当前总和低于要查找的数字，则递增第一个索引，否则递减第二个索引。

public static void findingIndex() {
         Arrays.sort(a);
         System.out.println(Arrays.toString(a));
         Scanner sc = new Scanner(System.in);
         System.out.println("Enter the sum of two selected numbers from the array");
         int i = sc.nextInt();
         int index1 = 0; 
         int index2 = a.length-1;
         while(index1 != index2){
            int sum = a[index1] + a[index2];
            if(sum == i){
                System.out.println("Found with "+index1+" "+index2);
                index1++;
            }
            else if (sum < i){
                index1++;
            } else {
                index1 = 0;
                index2--;
            }
         }
}

对O(nlogn)中的运行进行排序所需的时间以及while循环的复杂性将是 ~~O(n)~~ ，O(n²)，但它仍然使用一个循环。

因此算法的总体复杂性为O(n²)。

这可以很容易地转换成一个for循环：

for(int index1 = 0, index2 = a.length-1; index1 != index2;){
            int sum = a[index1] + a[index2];
            if(sum == i){
                System.out.println("Found with "+index1+" "+index2);
                index1++;
            }
            else if (sum < i){
                index1++;
            } else {
                index1 = 0;
                index2--;
            }
}

Answer 2

你可以用这种方式在O（n * log n）时间内完成。

public static int[] findSum(int[] values, int sum) {
    Arrays.sort(values);  // O(N * log N)
    for(int i = 0; i < values.length() - 1; i ++) { // O(n)
        int remainder = sum - values[i];
        // O(log N) and assuming you can't use the same value twice.
        int pos2 = Arrays.binarySearch(value, i + 1, values.length, remainder); 
        if (pos2 >= 0)
            return new int[] { i, pos2 };
    }
    return null;
}

所以总顺序是O（N log N）+ O（N）* O（log N）或者只是O（N log N）

Answer 3

任何场景都有一个最佳水平，我们无法进一步简化超出该水平。您可以尝试以下。

    Integer a[] = { 1, 2, 3, 5, 6, 7, 11, 12} ;
    List<Integer> list=new ArrayList<>();
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter the sum of two selected numbers from the array");
    int in = sc.nextInt();
    for(int i=0;i<a.length;i++){
        if(list.contains(in-a[i]) &&(list.indexOf(in-a[i])!=i)){
            System.out.println("The indexes of the elements are"
                                        +i+"and"+list.indexOf(in-a[i]));
        }
    }

但contains()方法自己有for-loop。

如何在条件中找到数组中数字的索引位置？

3 个答案: