Java程序查找所有零和的三元组

给定一组不同的元素。任务是在数组中找到总和为零的三元组。

例子 ：

Input : arr[] = {0, -1, 2, -3, 1}
Output : (0 -1 1), (2 -3 1)

Explanation : The triplets with zero sum are
0 + -1 + 1 = 0 and 2 + -3 + 1 = 0  

Input : arr[] = {1, -2, 1, 0, 5}
Output : 1 -2  1
Explanation : The triplets with zero sum is
1 + -2 + 1 = 0   

方法 1：这是一个简单的方法，需要 O(n ³ ) 时间才能得出结果。

• 方法：天真的方法运行三个循环，并一一检查三个元素的总和是否为零。如果三个元素的总和为零，则打印元素，否则打印未找到。
• 算法：
  1. 使用循环计数器i 、 j 、 k运行三个嵌套循环
  2. 第一个循环将从 0 运行到 n-3，第二个循环从 i+1 运行到 n-2，第三个循环从 j+1 运行到 n-1。循环计数器代表三元组的三个元素。
  3. 检查第 i'th, j'th, k'th 处的元素之和是否等于 0。如果是，则打印总和，否则继续。

下面是上述方法的实现：

Java

// A simple Java program to find three elements
// whose sum is equal to zero
class num{
// Prints all triplets in arr[] with 0 sum
static void findTriplets(int[] arr, int n)
{
    boolean found = false;
    for (int i=0; i

---

---

输出

0 -1 1
2 -3 1

复杂性分析：

• 时间复杂度： O(n 3 )。
由于需要三个嵌套循环，因此时间复杂度为 O(n 3 )。
• 辅助空间： O(1)。
由于不需要额外的空间，所以空间复杂度是恒定的。


方法2：第二种方法是利用Hashing的过程来得到结果，并在O(n 2 )的较小时间内求解。

方法：这涉及遍历数组。对于每个元素 arr[i]，找到总和为“-arr[i]”的对。这个问题简化为对和，并且可以使用散列在 O(n) 时间内解决。

算法：

1. 创建一个 hashmap 来存储一个键值对。
2. 运行一个包含两个循环的嵌套循环，外循环从 0 到 n-2，内循环从 i+1 到 n-1
3. 检查哈希图中是否存在第 i 个和第 j 个元素乘以 -1 的总和
4. 如果元素存在于哈希图中，则打印三元组，否则将第 j 个元素插入哈希图中。

下面是上述方法的实现：

Java

// Java program to find triplets in a given
// array whose sum is zero
import java.util.*;
  
class GFG 
{
  
    // function to print triplets with 0 sum
    static void findTriplets(int arr[], int n) 
    {
        boolean found = false;
  
        for (int i = 0; i < n - 1; i++) 
        {
            // Find all pairs with sum equals to
            // "-arr[i]"
            HashSet s = new HashSet();
            for (int j = i + 1; j < n; j++) 
            {
                int x = -(arr[i] + arr[j]);
                if (s.contains(x)) 
                {
                    System.out.printf("%d %d %d
", x, arr[i], arr[j]);
                    found = true;
                } 
                else 
                {
                    s.add(arr[j]);
                }
            }
        }
  
        if (found == false)
        {
            System.out.printf(" No Triplet Found
");
        }
    }
  
    // Driver code
    public static void main(String[] args) 
    {
        int arr[] = {0, -1, 2, -3, 1};
        int n = arr.length;
        findTriplets(arr, n);
    }
}
  
// This code contributed by Rajput-Ji

输出

-1 0 1
-3 2 1

复杂性分析：

• 时间复杂度： O(n 2 )。
由于需要两个嵌套循环，因此时间复杂度为 O(n 2 )。
• 辅助空间： O(n)。
由于需要hashmap，所以空间复杂度是线性的。


方法3：该方法使用Sorting得到正确的结果，并在O(n 2 )时间内求解。


方法：上述方法需要额外的空间。这个想法是基于这篇文章的方法2。对于每个元素，检查是否有一对总和等于该元素的负值。

算法：

1. 按升序对数组进行排序。
2. 从头到尾遍历数组。
3. 对于每个索引i ，创建两个变量l = i + 1和r = n – 1
4. 如果 array[i]、array[l] 和 array[r] 之和为零，则运行循环直到 l 小于 r，然后打印三元组并中断循环
5. 如果总和小于零，则增加 l 的值，通过增加 l 的值，总和将随着数组排序而增加，因此array[l+1] > array [l]
6. 如果总和大于零，则减少 r 的值，通过增加 l 的值，总和将随着数组的排序而减少，因此array[r-1] < array [r] 。

下面是上述方法的实现：

Java

// Java  program to find triplets in a given
// array whose sum is zero
import java.util.Arrays; 
import java.io.*;
  
class GFG {
    // function to print triplets with 0 sum
static void findTriplets(int arr[], int n)
{
    boolean found = false;
  
    // sort array elements
    Arrays.sort(arr);
  
    for (int i=0; i

输出

-3 1 2
-1 0 1

复杂性分析：

• 时间复杂度： O(n 2 )。
只需要两个嵌套循环，因此时间复杂度为 O(n 2 )。
• 辅助空间： O(1)，不需要额外的空间，所以时间复杂度是恒定的。

有关详细信息，请参阅有关查找所有零和三元组的完整文章！