# Find the largest pair sum in an unsorted array

Given an unsorted of distinct integers, find the largest pair sum in it. For example, the largest pair sum in {12, 34, 10, 6, 40} is 74.

Difficulty Level: Rookie
Expected Time Complexity: O(n) [Only one traversal of array is allowed]

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

This problem mainly boils down to finding the largest and second largest element in array. We can find the largest and second largest in O(n) time by traversing array once.

```1) Initialize both first and second largest
first = max(arr[0], arr[1])
second = min(arr[0], arr[1])
2) Loop through remaining elements (from 3rd to end)
a) If the current element is greater than first, then update first
and second.
b) Else if the current element is greater than second then update
second
3) Return (first + second)
```

Below is C++ and Java implementation of above algorithm.

## C++

```// C++ program to find largest pair sum in a given array
#include<iostream>
using namespace std;

/* Function to return largest pair sum. Assumes that
there are at-least  two elements in arr[] */
int findLargestSumPair(int arr[], int n)
{
// Initialize first and second largest element
int first, second;
if (arr[0] > arr[1])
{
first = arr[0];
second = arr[1];
}
else
{
first = arr[1];
second = arr[0];
}

// Traverse remaining array and find first and second largest
// elements in overall array
for (int i = 2; i<n; i ++)
{
/* If current element is greater than first then update both
first and second */
if (arr[i] > first)
{
second = first;
first = arr[i];
}

/* If arr[i] is in between first and second then update second  */
else if (arr[i] > second && arr[i] != first)
second = arr[i];
}
return (first + second);
}

/* Driver program to test above function */
int main()
{
int arr[] = {12, 34, 10, 6, 40};
int n = sizeof(arr)/sizeof(arr[0]);
cout << "Max Pair Sum is " << findLargestSumPair(arr, n);
return 0;
}
```

## Java

```// Java program to find largest pair sum in a given array

class Test
{
static int arr[] = new int[]{12, 34, 10, 6, 40};

/* Method to return largest pair sum. Assumes that
there are at-least  two elements in arr[] */
static int findLargestSumPair()
{
// Initialize first and second largest element
int first, second;
if (arr[0] > arr[1])
{
first = arr[0];
second = arr[1];
}
else
{
first = arr[1];
second = arr[0];
}

// Traverse remaining array and find first and second largest
// elements in overall array
for (int i = 2; i<arr.length; i ++)
{
/* If current element is greater than first then update both
first and second */
if (arr[i] > first)
{
second = first;
first = arr[i];
}

/* If arr[i] is in between first and second then update second  */
else if (arr[i] > second && arr[i] != first)
second = arr[i];
}
return (first + second);
}
// Driver method to test the above function
public static void main(String[] args)
{

System.out.println("Max Pair Sum is " + findLargestSumPair());

}
}
```

Output:
`Max Pair Sum is 74`

Time complexity of above solution is O(n).

# GATE CS Corner    Company Wise Coding Practice

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.
1.8 Average Difficulty : 1.8/5.0
Based on 75 vote(s)