Java 找到两个整数的最有效方法，在特定条件下求和为目标值_Java_Arrays_Algorithm

Java 找到两个整数的最有效方法，在特定条件下求和为目标值

java arrays algorithm

Java 找到两个整数的最有效方法，在特定条件下求和为目标值,java,arrays,algorithm,Java,Arrays,Algorithm,我正在寻找一种有效的方法，在特定条件下打印出两个整数，它们的总和等于目标值：第一个int应小于该对中的第二个int 打印应按对中的第一个递增我做了一些意大利面，在时间复杂度上似乎比两个循环更有效，但是，它不包括排序。我现在已经没有主意了我的问题如下：将输出排序的最佳方法是什么除了我当前的解决方案之外，还有其他方法可以提高时间复杂度吗另外，输入和输出将是大量整数，因此我想知道是否应该替换System.out.println 先谢谢你编辑：我必须把所有的对都打印出来。一个int可

我正在寻找一种有效的方法，在特定条件下打印出两个整数，它们的总和等于目标值：

第一个int应小于该对中的第二个int
打印应按对中的第一个递增

我做了一些意大利面，在时间复杂度上似乎比两个循环更有效，但是，它不包括排序。我现在已经没有主意了

我的问题如下：

将输出排序的最佳方法是什么

除了我当前的解决方案之外，还有其他方法可以提高时间复杂度吗

另外，输入和输出将是大量整数，因此我想知道是否应该替换System.out.println

先谢谢你

编辑：我必须把所有的对都打印出来。一个int可以是多对。输入可以增加到几十万整数

鉴于具体目标12：输入示例： 210084128

示例输出： 0 12 2 10 4 8 4.8

publicstaticvoidmyfindpair（int[]arr，int-target）{
//键=差，值=索引
Map Map=newhashmap（）；
对于（int i=0；i

首先对数组进行排序。如果排序了

arr

，并且

arr[0]+arr[arr.length-1]>目标

，则

arr[arr.length-1]

不可能成对出现；您将其添加到了尽可能小的值，但它对于目标来说仍然太大。类似地，如果

arr[0]+arr[arr.length]

，则arr[0]
不可能是一对的一部分。这将导致以下算法
public /* return type */ findPair(int[] arr, int target)
{
  Arrays.sort(arr);

  int i = 0, j = arr.length - 1;
  
  while (i < j) {
    int sum = arr[i] + arr[j];
    if (sum < target) i++;
    else if (sum > target) j--;
    else {
      /* sum == target, so add arr[i] and arr[j] to a set of solutions. */
      /* I'm assuming that the elements of arr are unique. */
      i++;
      j--;
    }
  }

  return /* set of solutions */
}

public/*返回类型*/findPair（int[]arr，int-target）
{
数组。排序（arr）；
int i=0，j=arr.length-1；
而（i目标）j--；
否则{
/*sum==target，因此将arr[i]和arr[j]添加到一组解中*/
/*我假设arr的元素是唯一的*/
i++；
j--；
}
}
return/*解决方案集*/
}
首先对数组进行排序。如果排序了arr
，并且arr[0]+arr[arr.length-1]>目标
，则arr[arr.length-1]
不可能成对出现；您将其添加到了尽可能小的值，但它对于目标来说仍然太大。类似地，如果arr[0]+arr[arr.length]
，则arr[0]
不可能是一对的一部分。这将导致以下算法
public /* return type */ findPair(int[] arr, int target)
{
  Arrays.sort(arr);

  int i = 0, j = arr.length - 1;
  
  while (i < j) {
    int sum = arr[i] + arr[j];
    if (sum < target) i++;
    else if (sum > target) j--;
    else {
      /* sum == target, so add arr[i] and arr[j] to a set of solutions. */
      /* I'm assuming that the elements of arr are unique. */
      i++;
      j--;
    }
  }

  return /* set of solutions */
}

public/*返回类型*/findPair（int[]arr，int-target）
{
数组。排序（arr）；
int i=0，j=arr.length-1；
而（i目标）j--；
否则{
/*sum==target，因此将arr[i]和arr[j]添加到一组解中*/
/*我假设arr的元素是唯一的*/
i++；
j--；
}
}
return/*解决方案集*/
}
以下是解决您的问题的一种可能的方法：

使用计数排序
让输入数组上的长度A=n

让输入范围，即数组的最大元素=k

算法：
Store the frequency of each element of the array A.
Use the frequency array to find pairs.

A = 2 10 0 8 4 12 8 4

private static void printPair(int[] A, int targetSum)
{
    //find the maximum element
    int max = A[0];

    for (int element: A) max = Math.max(max, element);    

    //Make a frequency array
    int[] frequency = new int[max+1];
    for (int element: A) frequency[element]++;

    //Find pairs
    for (int i = 0;i < frequency.length/2;i++)
    {
        if (targetSum - i < 0) break;

        if (frequency[i] > 0 && frequency[targetSum-i] > 0)
        {
            while (Math.min(frequency[i], frequency[targetSum-i]) > 0)
            {
                System.out.print("Pair: " + i + "\t" + (targetSum - i));
                System.out.println();

                frequency[i]--;
                frequency[targetSum - i]--;
            }
        }
    }
}

示例：
Store the frequency of each element of the array A.
Use the frequency array to find pairs.

A = 2 10 0 8 4 12 8 4

private static void printPair(int[] A, int targetSum)
{
    //find the maximum element
    int max = A[0];

    for (int element: A) max = Math.max(max, element);    

    //Make a frequency array
    int[] frequency = new int[max+1];
    for (int element: A) frequency[element]++;

    //Find pairs
    for (int i = 0;i < frequency.length/2;i++)
    {
        if (targetSum - i < 0) break;

        if (frequency[i] > 0 && frequency[targetSum-i] > 0)
        {
            while (Math.min(frequency[i], frequency[targetSum-i]) > 0)
            {
                System.out.print("Pair: " + i + "\t" + (targetSum - i));
                System.out.println();

                frequency[i]--;
                frequency[targetSum - i]--;
            }
        }
    }
}

以下是相应的频率阵列：
element:     0  1  2  3  4  5  6  7  8  9  10  11  12
frequency:   1  0  1  0  2  0  0  0  2  0  1   0   1

使用频率阵列，我们可以很容易地找到目标和为sayT
的按升序排列的对
我们知道，如果a
和b
是数组a
的元素，其中a
0
和b
0
的频率，那么这样的一对是可能的。这样我们就可以找到O（k）
中的所有对，其中k
=输入范围
解决方案代码：
Store the frequency of each element of the array A.
Use the frequency array to find pairs.

A = 2 10 0 8 4 12 8 4

private static void printPair(int[] A, int targetSum)
{
    //find the maximum element
    int max = A[0];

    for (int element: A) max = Math.max(max, element);    

    //Make a frequency array
    int[] frequency = new int[max+1];
    for (int element: A) frequency[element]++;

    //Find pairs
    for (int i = 0;i < frequency.length/2;i++)
    {
        if (targetSum - i < 0) break;

        if (frequency[i] > 0 && frequency[targetSum-i] > 0)
        {
            while (Math.min(frequency[i], frequency[targetSum-i]) > 0)
            {
                System.out.print("Pair: " + i + "\t" + (targetSum - i));
                System.out.println();

                frequency[i]--;
                frequency[targetSum - i]--;
            }
        }
    }
}

这里,
k
几乎等于n^2
。因此，解决方案的时间复杂度变为O（n+n^2）
=O（n^2）
。因此，时间复杂度严格取决于可能的输入类型

我希望我帮助过你。我没有详细介绍解决方案代码，因为这样做会使答案太长。但是，如果您在理解解释、解决方案代码方面有困难，或者您还希望我发布第二个可能的解决方案，请发表评论。我很乐意帮助您。
以下是解决您问题的一种可能方法：

使用计数排序
让输入数组上的长度A=n

让输入范围，即数组的最大元素=k

算法：
Store the frequency of each element of the array A.
Use the frequency array to find pairs.

A = 2 10 0 8 4 12 8 4

private static void printPair(int[] A, int targetSum)
{
    //find the maximum element
    int max = A[0];

    for (int element: A) max = Math.max(max, element);    

    //Make a frequency array
    int[] frequency = new int[max+1];
    for (int element: A) frequency[element]++;

    //Find pairs
    for (int i = 0;i < frequency.length/2;i++)
    {
        if (targetSum - i < 0) break;

        if (frequency[i] > 0 && frequency[targetSum-i] > 0)
        {
            while (Math.min(frequency[i], frequency[targetSum-i]) > 0)
            {
                System.out.print("Pair: " + i + "\t" + (targetSum - i));
                System.out.println();

                frequency[i]--;
                frequency[targetSum - i]--;
            }
        }
    }
}

示例：
Store the frequency of each element of the array A.
Use the frequency array to find pairs.

A = 2 10 0 8 4 12 8 4

private static void printPair(int[] A, int targetSum)
{
    //find the maximum element
    int max = A[0];

    for (int element: A) max = Math.max(max, element);    

    //Make a frequency array
    int[] frequency = new int[max+1];
    for (int element: A) frequency[element]++;

    //Find pairs
    for (int i = 0;i < frequency.length/2;i++)
    {
        if (targetSum - i < 0) break;

        if (frequency[i] > 0 && frequency[targetSum-i] > 0)
        {
            while (Math.min(frequency[i], frequency[targetSum-i]) > 0)
            {
                System.out.print("Pair: " + i + "\t" + (targetSum - i));
                System.out.println();

                frequency[i]--;
                frequency[targetSum - i]--;
            }
        }
    }
}

以下是相应的频率阵列：
element:     0  1  2  3  4  5  6  7  8  9  10  11  12
frequency:   1  0  1  0  2  0  0  0  2  0  1   0   1

使用频率阵列，我们可以很容易地找到目标和为sayT
的按升序排列的对
我们知道，如果a
和b
是数组a
的元素，其中a
0
和b
0
的频率，那么这样的一对是可能的。这样我们就可以找到O（k）
中的所有对，其中k
=输入范围
解决方案代码：
Store the frequency of each element of the array A.
Use the frequency array to find pairs.

A = 2 10 0 8 4 12 8 4

private static void printPair(int[] A, int targetSum)
{
    //find the maximum element
    int max = A[0];

    for (int element: A) max = Math.max(max, element);    

    //Make a frequency array
    int[] frequency = new int[max+1];
    for (int element: A) frequency[element]++;

    //Find pairs
    for (int i = 0;i < frequency.length/2;i++)
    {
        if (targetSum - i < 0) break;

        if (frequency[i] > 0 && frequency[targetSum-i] > 0)
        {
            while (Math.min(frequency[i], frequency[targetSum-i]) > 0)
            {
                System.out.print("Pair: " + i + "\t" + (targetSum - i));
                System.out.println();

                frequency[i]--;
                frequency[targetSum - i]--;
            }
        }
    }
}

这里,
k
几乎等于n^2
。因此，解决方案的时间复杂度变为O（n+n^2）
=O（n^2）
。因此，时间复杂度严格取决于可能的输入类型

我跳