以给定的总和打印所有三胞胎

给定一系列不同的元素。任务是在数组中找到三元组，其总数等于给定的数字。
例子：

Input: arr[] = {0, -1, 2, -3, 1}
        sum = -2
Output:  0 -3  1
        -1  2 -3
If we calculate the sum of the output,
0 + (-3) + 1 = -2
(-1) + 2 + (-3) = -2

Input: arr[] = {1, -2, 1, 0, 5}
       sum = 0
Output: 1 -2  1
If we calculate the sum of the output,
1 + (-2) + 1 = 0

方法1 ：蛮力。
方法：此类问题中的蛮力方法旨在检查数组中存在的所有可能的三元组。 sum =目标总和的三元组将是答案。现在出现的问题是如何检查所有可能的三胞胎。要检查所有可能小芯片固定在一个元件上的指针和对每个这样的元件遍历数组和检查总和。这将是所有可能的duplet的总和。
同样，对于检查所有可能的三元组，可以固定两个指针并将第三个指针移到数组上，一旦到达数组末尾，就增加第二个指针并再次重复该指针。
算法：

1. 取三个指针i ， j ， k 。
2. 用零初始化i并为i启动一个嵌套循环。
3. 用(i + 1)初始化j并为j启动一个嵌套循环。
4. 用(j + 1)初始化k并开始k的循环。
5. 如果Target == arr [i] + arr [j] + arr [k]中断循环并打印arr [i]，arr [j]，arr [k]的值。
6. 否则，继续增加k直到它等于最后一个索引。
7. 转到步骤2和增量j和对于j的每一个值运行k的内部循环。
8. 如果j等于倒数第二个索引，则转到步骤1 ，将i的值增加到倒数第三个索引，然后再次继续整个过程，直到i的值等于最后一个索引。

C++

// A simple C++ program to find three elements
// whose sum is equal to given sum
#include 
using namespace std;
 
// Prints all triplets in arr[] with given sum
void findTriplets(int arr[], int n, int sum)
{
    for (int i = 0; i < n - 2; i++) {
        for (int j = i + 1; j < n - 1; j++) {
            for (int k = j + 1; k < n; k++) {
                if (arr[i] + arr[j] + arr[k] == sum) {
                    cout << arr[i] << " "
                         << arr[j] << " "
                         << arr[k] << endl;
                }
            }
        }
    }
}
 
// Driver code
int main()
{
    int arr[] = { 0, -1, 2, -3, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
    findTriplets(arr, n, -2);
    return 0;
}

Java

// A simple Java program
// to find three elements
// whose sum is equal to
// given sum
import java.io.*;
 
class GFG {
 
    // Prints all triplets in
    // arr[] with given sum
    static void findTriplets(int arr[],
                             int n, int sum)
    {
        for (int i = 0;
             i < n - 2; i++) {
            for (int j = i + 1;
                 j < n - 1; j++) {
                for (int k = j + 1;
                     k < n; k++) {
                    if (arr[i] + arr[j] + arr[k] == sum) {
                        System.out.println(
                            arr[i] + " " + arr[j]
                            + " " + arr[k]);
                    }
                }
            }
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 0, -1, 2, -3, 1 };
        int n = arr.length;
        findTriplets(arr, n, -2);
    }
}
 
// This code is contributed by m_kit

Python 3

# A simple Python 3 program
# to find three elements
# whose sum is equal to
# given sum
 
# Prints all triplets in
# arr[] with given sum
def findTriplets(arr, n, sum):
 
    for i in range(0, n - 2):
        for j in range(i + 1, n - 1):
            for k in range(j + 1, n):
                if (arr[i] + arr[j] +
                    arr[k] == sum):
                    print(arr[i], " ",
                          arr[j], " ",
                          arr[k], sep = "")
             
# Driver code
arr = [ 0, -1, 2, -3, 1 ]
n = len(arr)
findTriplets(arr, n, -2)
 
# This code is contributed
# by Smitha

C#

// A simple C# program
// to find three elements
// whose sum is equal to
// given sum
using System;
 
class GFG {
 
    // Prints all triplets in
    // arr[] with given sum
    static void findTriplets(int[] arr,
                             int n, int sum)
    {
        for (int i = 0;
             i < n - 2; i++) {
            for (int j = i + 1;
                 j < n - 1; j++) {
                for (int k = j + 1;
                     k < n; k++) {
                    if (arr[i] + arr[j] + arr[k] == sum) {
                        Console.WriteLine(
                            arr[i] + " " + arr[j]
                            + " " + arr[k]);
                    }
                }
            }
        }
    }
 
    // Driver code
    static public void Main()
    {
        int[] arr = { 0, -1, 2, -3, 1 };
        int n = arr.Length;
        findTriplets(arr, n, -2);
    }
}
// This code is contributed by akt_mit

Javascript

 
// A simple Javascript program to find three elements
// whose sum is equal to given sum
 
// Prints all triplets in arr[] with given sum
function findTriplets(arr, n, sum)
{
    for (let i = 0; i < n - 2; i++) {
        for (let j = i + 1; j < n - 1; j++) {
            for (let k = j + 1; k < n; k++) {
                if (arr[i] + arr[j] + arr[k] == sum) {
                    document.write(arr[i]+ " "
                        + arr[j] + " "
                        + arr[k] + "<br>");
                }
            }
        }
    }
}
 
// Driver code
 
    let arr = [ 0, -1, 2, -3, 1 ];
    let n = arr.length;
    findTriplets(arr, n, -2);
 
// This code is contributed by Mayank Tyagi
 

---

输出 ：

0 -3 1
-1 2 -3

复杂度分析：

• 时间复杂度： O(n ³ )。
  由于使用了三个嵌套的for循环。
• 辅助空间： O(1)。
  由于尚未使用任何数据结构来存储值。

方法2 ：散列。
方法：
散列可用于解决此问题。 HashTable或HashMaps允许我们以恒定的时间复杂度执行查找或搜索操作。如果可以发现对于每个可能的二元组，数组中已经存在一个可以使sum = target sum的元素，那么该问题将以有效的方式解决。
要实现哈希，我们可以在C++中使用unordered_set或在Java使用HashSet。

• 当我们修复第一个指针(例如a)时，请使用第二个指针(例如b)遍历数组，并继续将遇到的元素存储在HashTable中。
• 一旦我们发现等于HashTable中已经存在的剩余总和(目标总和-(a + b))的元素，我们将打印三元组。

算法：

1. 从i = 0到第(n-2)个索引开始外循环。
2. 对于每次迭代，请创建一个无序集合，然后进入内部循环。
3. 从j =(i + 1)开始内部循环[(因为我们已经检查过的值将不会出现在有效的三元组中)，直到最后一个索引为止。
4. 检查是否存在元素x =目标-(arr [i] + arr [j]) ，然后找到三元组并进行打印。
5. 否则将值推入集合中，以供以后参考。
6. 递增i并转到步骤2。

伪代码：

Run a loop from i=0 to n-2
  Create an empty hash table
  Run inner loop from j=i+1 to n-1
      If -(arr[i] + arr[j]) is present in hash table
         print arr[i], arr[j] and -(arr[i] + arr[j])
      Else
         Insert arr[j] in hash table.

C++

// C++ program to find triplets in a given
// array whose sum is equal to given sum.
#include 
using namespace std;
 
// function to print triplets with given sum
void findTriplets(int arr[], int n, int sum)
{
    for (int i = 0; i < n - 1; i++) {
        // Find all pairs with sum equals to
        // "sum-arr[i]"
        unordered_set s;
        for (int j = i + 1; j < n; j++) {
            int x = sum - (arr[i] + arr[j]);
            if (s.find(x) != s.end())
                printf("%d %d %d\n", x, arr[i], arr[j]);
            else
                s.insert(arr[j]);
        }
    }
}
 
// Driver code
int main()
{
    int arr[] = { 0, -1, 2, -3, 1 };
    int sum = -2;
    int n = sizeof(arr) / sizeof(arr[0]);
    findTriplets(arr, n, sum);
    return 0;
}

Java

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

Python3

# Python3 program to find triplets in a given
# array whose Sum is equal to given sum.
import math as mt
 
# function to print triplets with given sum
def findTriplets(arr, n, Sum):
 
    for i in range(n - 1):
         
        # Find all pairs with Sum equals
        # to "Sum-arr[i]"
        s = dict()
        for j in range(i + 1, n):
            x = Sum - (arr[i] + arr[j])
            if x in s.keys():
                print(x, arr[i], arr[j])
            else:
                s[arr[j]] = 1
         
# Driver code
arr = [ 0, -1, 2, -3, 1 ]
Sum = -2
n = len(arr)
findTriplets(arr, n, Sum)
 
# This code is contributed
# by mohit kumar 29

C＃

// C# program to find triplets in a given
// array whose sum is equal to given sum.
using System;
using System.Collections.Generic;
 
public class GFG {
 
    // function to print triplets with given sum
    static void findTriplets(int[] arr, int n, int sum)
    {
        for (int i = 0; i < n - 1; i++) {
            // Find all pairs with sum equals to
            // "sum-arr[i]"
            HashSet s = new HashSet();
            for (int j = i + 1; j < n; j++) {
                int x = sum - (arr[i] + arr[j]);
                if (s.Contains(x))
                    Console.Write("{0} {1} {2}\n", x, arr[i], arr[j]);
                else
                    s.Add(arr[j]);
            }
        }
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 0, -1, 2, -3, 1 };
        int sum = -2;
        int n = arr.Length;
        findTriplets(arr, n, sum);
    }
}
// This code is contributed by Princi Singh

输出：

-3 0 1
2 -1 -3

复杂度分析：

• 时间复杂度： O(n ² )。
  使用嵌套的for循环会将时间复杂度提高到n ² 。
• 辅助空间： O(n)。
  由于unordered_set数据结构已用于存储值。

方法3 ：此方法使用排序和两指针技术的方法来解决上述问题。该执行将涉及O(n ² ))时间复杂度和O(1)空间复杂度。这个想法是基于本文的方法2。
方法：可使用排序技术将两个指针技术付诸实践。在二指针技术中，人们可以在线性时间内搜索具有目标和的一对。这里的想法是修复一个指针(比如说a) ，然后使用剩余的指针来高效地找到一对具有所需总和目标值at(a)的指针。
现在让我们讨论如何使用两个指针技术有效地找到所需的对。用于两种指针技术的指针为say (l和r) 。

• 因此，如果总和=值(a)+值(l)+值(r)超过了要求的总和，则对于相同的(a，l) ，要求的值(r)应小于前一个值。因此，递减r指针。
• 如果总和=值(a)+值(l)+值(r)小于要求的总和，则对于相同的(a，r) ，要求的值(l)应大于前一个值。因此，增加l指针。

算法：

1. 对数组进行排序，然后为每个元素arr [i]搜索其他两个元素arr [l]，arr [r] ，使arr [i] + arr [l] + arr [r] = Target sum 。
2. 在对数组进行排序时，可以使用双指针技术高效地搜索其他两个元素。
3. 运行一个以contol变量为i的外循环，并为每次迭代初始化一个值l ，该值是第一个指针与i + 1以及r与最后一个索引。
4. 现在进入一个while循环，该循环将一直运行到l 的值。
5. 如果arr [i] + arr [l] + arr [r]>目标总和，则将r减1，因为所需的总和小于当前总和，并且减小的值将是有需要的。
6. 如果arr [i] + arr [l] + arr [r] <目标总和，则将l加1，因为所需的总和小于当前总和，并且增加的值将是有需要的。
7. 如果arr [i] + arr [l] + arr [r] == Target sum，则打印值。
8. 增量我转到步骤3。

伪代码：

1. Sort all element of array
2. Run loop from i=0 to n-2.
     Initialize two index variables l=i+1 and r=n-1
4. while (l < r) 
     Check sum of arr[i], arr[l], arr[r] is
     given sum or not if sum is 'sum', then print 
     the triplet and do l++ and r--.
5. If sum is less than given sum then l++
6. If sum is greater than given sum then r--
7. If not exist in array then print not found.

C++

// C++ program to find triplets in a given
// array whose sum is given sum.
#include 
using namespace std;
 
// Function to print triplets with given sum
    vector> findTriplets(int nums[],int n,int sumTarget) {
        vector> res;       
        if(n <=2) return res;
         
        sort(nums,nums + n);
         
        for(int i=0;i0 && nums[i] == nums[i-1])  // avoid duplicate triplets count
                continue;
             
            int num = nums[i];
            int target = sumTarget - num;
             
            for(int l=i+1, r=n-1; l target)                    
                    r--;
                 
                else if (nums[l]+nums[r] < target)
                    l++;
                 
                else {
                    // nums[l] + nums[r] == target
                    res.push_back({nums[i], nums[l], nums[r]});
 
                    // skip duplicates
                    while( l0 && nums[r]==nums[r-1]) r--;
                                             
                    l++;
                    r--;                   
                     
                }
                 
            }                                 
             
        }
        return res;          
    }
// Driver code
int main()
{
    int arr[] = { 0, -1, 2, -3, 1, -1, 3, 0};
    int sum = -2;
    int n = sizeof(arr) / sizeof(arr[0]);
    vector> res = findTriplets(arr, n, sum);
    cout<<"Unique triplets found are : \n";
    for(int i = 0;i

Java

// Java program to find triplets
// in a given array whose sum
// is given sum.
import java.io.*;
import java.util.*;
 
class GFG {
 
    // function to print
    // triplets with given sum
    static void findTriplets(int[] arr,
                             int n, int sum)
    {
        // sort array elements
        Arrays.sort(arr);
 
        for (int i = 0;
             i < n - 1; i++) {
            // initialize left and right
            int l = i + 1;
            int r = n - 1;
            int x = arr[i];
            while (l < r) {
                if (x + arr[l] + arr[r] == sum) {
                    // print elements if it's
                    // sum is given sum.
                    System.out.println(
                        x + " " + arr[l] + " "
                        + arr[r]);
                    l++;
                    r--;
                }
 
                // If sum of three elements
                // is less than 'sum' then
                // increment in left
                else if (x + arr[l] + arr[r] < sum)
                    l++;
 
                // if sum is greater than
                // given sum, then decrement
                // in right side
                else
                    r--;
            }
        }
    }
 
    // Driver code
    public static void main(String args[])
    {
        int[] arr = new int[] { 0, -1, 2, -3, 1 };
        int sum = -2;
        int n = arr.length;
        findTriplets(arr, n, sum);
    }
}
 
// This code is contributed
// by Akanksha Rai(Abby_akku)

Python3

# Python3 program to find triplets in a
# given array whose sum is given sum.
 
# function to print triplets with
# given sum
def findTriplets(arr, n, sum):
 
    # sort array elements
    arr.sort();
 
    for i in range(0, n - 1):
         
        # initialize left and right
        l = i + 1;
        r = n - 1;
        x = arr[i];
        while (l < r) :
            if (x + arr[l] + arr[r] == sum) :
                 
                # print elements if it's sum
                # is given sum.
                print(x, arr[l], arr[r]);
                l = l + 1;
                r = r - 1;
             
            # If sum of three elements is less
            # than 'sum' then increment in left
            elif (x + arr[l] + arr[r] < sum):
                l = l + 1;
 
            # if sum is greater than given sum,
            # then decrement in right side
            else:
                r = r - 1;
         
# Driver code
arr = [ 0, -1, 2, -3, 1 ];
sum = -2;
n = len(arr);
findTriplets(arr, n, sum);
 
# This code is contributed by
# Shivi_Aggarwal

C＃

// C# program to find triplets
// in a given array whose sum
// is given sum.
using System;
 
class GFG {
 
    // function to print
    // triplets with given sum
    static void findTriplets(int[] arr,
                             int n, int sum)
    {
        // sort array elements
        Array.Sort(arr);
 
        for (int i = 0; i < n - 1; i++) {
            // initialize left and right
            int l = i + 1;
            int r = n - 1;
            int x = arr[i];
            while (l < r) {
                if (x + arr[l] + arr[r] == sum) {
                    // print elements if it's
                    // sum is given sum.
                    Console.WriteLine(x + " " + arr[l] + " " + arr[r]);
                    l++;
                    r--;
                }
 
                // If sum of three elements
                // is less than 'sum' then
                // increment in left
                else if (x + arr[l] + arr[r] < sum)
                    l++;
 
                // if sum is greater than
                // given sum, then decrement
                // in right side
                else
                    r--;
            }
        }
    }
 
    // Driver code
    static int Main()
    {
        int[] arr = new int[] { 0, -1, 2, -3, 1 };
        int sum = -2;
        int n = arr.Length;
        findTriplets(arr, n, sum);
        return 0;
    }
}
 
// This code is contributed by rahul

输出：

-3 -1 2
-3 0 1

复杂度分析：

• 时间复杂度： O(n ² )。
  使用嵌套循环(一个用于迭代，另一个用于两指针技术)将时间复杂度提高到O(n ² )。
• 辅助空间： O(1)。
  由于不使用额外的数据结构。