给定一个由 N 个整数组成的数组 A，返回最大的整数 K>0，使得数组 A 中同时存在 K 和 -K（相反的数）

Question

Write a function solution, given an array A of N integers, return the largest integer K>0 such that both K and -K(the opposite number) exist in array A. If there is no such number the function should return 0.

Example:
1. Given A = [3,2,-2,5,-3], the function should return 3.
2. Given A = [1,2,3,-4], the function should return zero.

boolean found = false;
        int[] ar = { -5, -4, -1, -5, -4 };
        Arrays.sort(ar);
        for (int i = ar.length - 1; i >= 0; i--) {
            for (int j = 0; j <= ar.length - 1; j++) {
                if (ar[i] + ar[j] == 0) {
                    System.out.println(Math.abs(ar[i]));
                    found = true;
                    break;
                }
            }
            if (found == true) {
                break;
            }
        }
        if (found == false) {
            System.out.println("0");
        }
    }

Can someone please review the solution for time complexity and share your comments.

Also, i need some help for same question in C# (me having no experience in C#)

Answer 1

Your current solution has O(n**2) time complexity since the solution uses nested loops:

 for (int i = ar.length - 1; i >= 0; i--) {    // O(n)
   for (int j = 0; j <= ar.length - 1; j++) {  // O(n)
     ...

Here

 O(n) * O(n) = O(n**2)

You can try hashing (let it be Linq C# ) for O(n) time complexity

1. Given an array, say { 3, 2, -2, 5, -3 }
2. We can group by absolute values: 3 : {3, -3}, 2 : {2, -2}, 5 : {5}
3. Then filter to keep the groups with 2 distinct items: 3 : {3, -3}, 2 : {2, -2}
4. Finally, we should take the max key: 3

Code:

private static int MySolution(IEnumerable<int> array) => array
  .GroupBy(item => Math.Abs(item))                // O(n) 
  .Where(group => group.Distinct().Count() == 2)  // O(n)
  .Select(group => group.Key)                     // O(n) 
  .DefaultIfEmpty()                               // O(1)
  .Max();                                         // O(n)

Here

O(n) + O(n) + O(n) + O(1) + O(n) = O(n) 

Demo:

  int[][] tests = new int[][] {
    new int[] { 1, 2, 3, -4 },
    new int[] { 3, 2, -2, 5, -3 },
    new int[] { 3, 2, -2, 5, 3 },  // no -3, but 3 appears twice
    new int[] { }
  };

  string result = string.Join(Environment.NewLine, tests
    .Select(test => $"{("[" + string.Join(", ", test) + "]").PadRight(20)} => {MySolution(test)}"));

  Console.Write(result);

Outcome:

[1, 2, 3, -4]        => 0
[3, 2, -2, 5, -3]    => 3
[3, 2, -2, 5, 3]     => 2
[]                   => 0

Answer 2

Just the Array.sort will raise your time complexity to as much as O(n^2). Best case O(n logn)

Source: https://www.baeldung.com/arrays-sortobject-vs-sortint

I will argue that you don't need it at all. Remove it and just don't compare for i==j in your second loop.

The two for loops will cause a complexity of O(n^2) as you do a full scan for each value in your worst case scenario where there are no matches. So even if you totally remove the sorting, you are still at the same bad performance.

You can make it better by starting always at the next element from the previous once you checked.

Food for thought: You can also add complexity in terms of space and just find the answer in one iteration from all the items. Retrieval from a Hasmap or a Hashset is O(1).