Java 如何在一个数组中找到两个相乘到某个数字的值

我要做的是搜索一个数组，找出是否有两个数字相乘到225。以下是我现在拥有的：

    int n = A.length;

    for(int i = 0; i >= n; i++){
        for(int j = 0; j >= n; j++){
            if(i == j){
            }
            else if(A[i] * A[j] == 225){
                return true;
            }
        }
    }
    return false;
}

---

它会找到数组中的第一个值，并将其与其他值相乘，一旦找到两个225的数字，则返回true。我也这样做，如果I和j是相同的数字，那么它什么也不做，因为我不希望它比较相同位置的值。问题是，即使在两个数相乘为225的数组中（如15、45、60、15），它也会不断返回false。那么我的代码出了什么问题

for循环有1个问题：

应该是这样的：

int n = A.length;
for(int i = 0; i < n; i++)
    for(int j = 0; j < n; j++)
        if(i != j)
            if(A[i] * A[j] == 225)
                return true;

int n=A.length；
对于（int i=0；i

此外，您可以稍微优化此循环，以：

int n = A.length;
for(int i = 0; i < (n-1); i++)
    for(int j = (i+1); j < n; j++)
        if (A[i] * A[j] == 225)
            return true;

int n=A.length；
对于（int i=0；i<（n-1）；i++）
对于（int j=（i+1）；j

这是一个稍微不同的版本，它的平均复杂度为O（N）：

final Map set=新的HashMap（A.length）；
对于（最终int i:A）{
set.put（i，set.containsKey（i））；//存储数组中的数字，如果两个数字多次出现，则设置为true
}
对于（最终int i:A）{
最终整数倍数=225/i；
如果（（mult*i）=225）{//测试整数乘法导致225
最终布尔值m=set.get（mult）；
如果（m！=null）{//我们在集合中有两个数字，现在我们应该过滤重复计数
if（（i！=mult）| |（（i==mult）和&m.booleanValue（））
返回true；
}
}
}
返回false；

这里是数组。sort（）在内部使用快速排序

public class FindMultiplicationValueUsingpointer 
{
    private void operation(int [] arr, int required)
    {//2, 3, 4, 5, 6, 7
        Arrays.sort(arr);
        int right =arr.length-1;
        int left= 0, val;

            while(left<right)
            {
                System.out.println("left is "+arr[left]);
                System.out.println("right is "+arr[right]);
                val = arr[left]*arr[right];
                System.out.println("value is " +val);
                if(val<required)
                {
                    left = left+1;

                }
                else if(val>required)
                {
                    right=right-1;
                }

                else if(val==required)
                {
                    System.out.println("value matched");
                    break;

                }
            }   

    }

    public static void main(String[] args) 
    {
        int arr[] = {3, 2, 6, 7, 4, 5};
        int required = 20;
        FindMultiplicationValueUsingpointer  up = new FindMultiplicationValueUsingpointer();
        up.operation(arr, required);

    }

公共类使用指针查找多应用程序值
{
私有无效操作（int[]arr，需要int）
{//2, 3, 4, 5, 6, 7
数组。排序（arr）；
int right=arr.length-1；
int left=0，val；
而（左也可以使用hashset对任何数字执行一个for循环，这也将最小化迭代次数。最佳情况为o（1），最坏情况为o（n）：

public boolean hasAnyPair（int[]arr，int n）{
布尔hasPair=false；
HashSet=newhashset（）；
对于（int i=0；i=arr[i]&&n%arr[i]==0）{
集合。添加（arr[i]）；
if（集合包含（n/arr[i]））{
hasPair=true；
打破
}
}
}
返回hasPair；
}
我的原始算法的运行时间是O（n^2）。优化循环的运行时间是多少？@JoshSusa复杂度是相同的O（n^2），但实际运行时间是（n^2）/2是否可以将运行时间设为O（n）或O（nlogn）？
public class FindMultiplicationValueUsingpointer 
{
    private void operation(int [] arr, int required)
    {//2, 3, 4, 5, 6, 7
        Arrays.sort(arr);
        int right =arr.length-1;
        int left= 0, val;

            while(left<right)
            {
                System.out.println("left is "+arr[left]);
                System.out.println("right is "+arr[right]);
                val = arr[left]*arr[right];
                System.out.println("value is " +val);
                if(val<required)
                {
                    left = left+1;

                }
                else if(val>required)
                {
                    right=right-1;
                }

                else if(val==required)
                {
                    System.out.println("value matched");
                    break;

                }
            }   

    }

    public static void main(String[] args) 
    {
        int arr[] = {3, 2, 6, 7, 4, 5};
        int required = 20;
        FindMultiplicationValueUsingpointer  up = new FindMultiplicationValueUsingpointer();
        up.operation(arr, required);

    }

   public boolean  hasAnyPair(int[] arr, int n) {


        boolean hasPair=false;
        HashSet<Integer> set= new HashSet<Integer>();

        for(int i=0; i<arr.length; i++) {

            if(n>=arr[i] && n%arr[i]==0) {
                set.add(arr[i]);
                if(set.contains(n/arr[i])) {
                    hasPair=true;
                    break;
                }
            }

        }

        return hasPair;

    }