Java 如何实现双和（无哈希-仅使用数组代码）？

我试图用eclipse做一个二和问题。我想使用一个数组，让程序执行一个标准递归，看看下面列出的数组中的任何整数是否可以相加等于我的目标和9

这就是我正在解决的问题，并且在实施我的策略时遇到了困难。。。（注意，我尝试过对我的编码进行多种解释）

给定一个整数数组，返回两个数字的索引，使它们相加到一个特定的目标

您可以假设每个输入都有一个解决方案，并且不能两次使用同一个元素

例如：

给定nums=[2,7,11,15]，target=9

因为nums[0]+nums[1]=2+7=9，所以返回[0,1]

import java.util.ArrayList；
公共类数组{
公共twoSumArray（int[]nums，int目标）
{
对于（int i=0；i

我试过的另一个代码

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

    public static void main(String[] args) {
        int[] nums = {2,7,11,15};
        twoSum(nums , 9);
    }
}

类解决方案{
公共静态int[]twoSum（int[]nums，int目标）
{
对于（int i=0；i

您需要使用gready方法来完成此操作，您可以开始对最大值（结果）以下的任何数字序列求和

每次选择似乎是最佳选择的数字（最佳选择意味着它与前一个和的总和不大于所需结果） 在得到所有可能的组合或使用回溯之前，不重复地强制执行此操作。当溢出结果并测试其他组合选项时，回溯步骤数 这比简单的朴素野蛮的暴力方法要快得多，而这种方法必须经过测试 如果我给你一个足够大的数组，nlog（n）组合是不真实的

---

编辑：我注意到在一篇评论后，它添加了两个数字而不是一个集合，然后更简单。首先，蛮力天真的方法在这里是最糟糕的，因为除了加法运算，数字在等式中的位置并不重要，所以你测试每一个数字，直到N-1它的N*2-1可比性，而不是N^2代码中有一些语法错误。为了简洁起见，我将发布一个关于您试图实现的目标的最小示例

如果不进行哈希运算，您将无法得到运行在

O（n^2）

但是，您可以在不进行散列的情况下获得一个

O（n^2）

（您的第二个解决方案实际上在逻辑上是正确的，但在语法上是错误的。）例如，为什么要打印

System.out.println（twoSum.solution）？你调用
twoSum（nums，9）但您从未实际打印结果

public class TwoSum {
    public static void main(String[] args) {
        int[] answer = twoSum(new int[]{1, 2, 3}, 4);
        if (answer != null)
            System.out.println("[" + answer[0] + ", " + answer[1] + "]");
    }

    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[i] + numbers[j] == target) return new int[]{ i, j };
            }
        }
        // no answer
        return null;
    }
}

公共类TwoSum{
公共静态void main（字符串[]args）{
int[]answer=twoSum（新的int[]{1,2,3}，4）；
如果（回答！=null）
System.out.println（“[”+答案[0]+”，“+答案[1]+”）”；
}
公共静态int[]twoSum（int[]数字，int目标）{
for（int i=0；i

这种解决方案通常不受欢迎，因为它不是最有效的，而且是一种蛮力算法。但是，它非常简单，不需要太多思考就可以理解。
您确实要求使用递归解决方案。这是可行的，但它确实需要为
vals
数组提供起始索引

int[]vals={1,2,7,9,5,3,10}；
System.out.println（Arrays.toString（twoSum（vals，0，1，15））；
公共静态int[]twoSum（int[]v，int n，int m，int目标）{
如果（n==v.length）{
返回新的int[]{-1，-1
};
}
如果（m==v.length）{
返回twoSum（v，n+1，n+2，目标）；
}
如果（v[n]+v[m]==目标）{
返回新的int[]{n，m
};
}
返回twoSum（v，n，m+1，target）；
}

如果未找到总和，则返回一个
[-1，-1]
数组。还可以返回空数组，甚至
null

这应该很容易理解。它基本上像两个嵌套循环一样工作，适当地递增
n
和
m
，并检查
不变量
，以确保索引不等于数组长度

但是，如果您只需要一个普通的旧嵌套循环解决方案，其行为方式与您可以执行以下操作完全相同：

公共静态int[]twoSum（int[]v，int目标）{
对于（int n=0；n
是否存在时间复杂度限制？您没有说哪里出了问题。你得到了错误的答案吗？超时？运行时错误？计算机突然进入