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

编写一个函数解决方案，给定一个由N个整数组成的数组a，返回最大整数K>0，这样数组a中同时存在K和-K（相反的数字）。如果没有这样的数字，函数应返回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}；
数组。排序（ar）；
对于（int i=ar.length-1；i>=0；i--）{
对于（int j=0；j仅使用
数组。sort
将时间复杂度提高到O（n^2）。最佳情况为O（n logn）

资料来源：

我会说你根本不需要它。删除它，只是不要在你的第二个循环中比较I==j

这两个for循环将导致O（n^2）的复杂性，因为在没有匹配项的最坏情况下，您对每个值进行完全扫描。因此，即使您完全删除排序，您的性能仍然相同

检查后，可以始终从上一个元素的下一个元素开始，从而使其更好

值得思考的是：你也可以增加空间的复杂性，只需在一次迭代中从所有项目中找到答案。从Hasmap或Hashset中检索是O（1）。
只需
数组。排序将把你的时间复杂性提高到O（n^2）。最佳情况是O（n logn）

资料来源：

我会说你根本不需要它。删除它，只是不要在你的第二个循环中比较I==j

这两个for循环将导致O（n^2）的复杂性，因为在没有匹配项的最坏情况下，您对每个值进行完全扫描。因此，即使您完全删除排序，您的性能仍然相同

检查后，可以始终从上一个元素的下一个元素开始，从而使其更好

值得思考的是：您还可以增加空间方面的复杂性，只需在一次迭代中从所有项中找到答案。从Hasmap或Hashset中检索是O（1）。
您当前的解决方案具有
O（n**2）
时间复杂性，因为解决方案使用嵌套循环：

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

您可以尝试对时间复杂度
O（n）
进行哈希运算（让它成为LinqC）

给定一个数组，比如说
{3,2，-2,5，-3}
我们可以按绝对值分组：
3:{3，-3}，2:{2，-2}，5:{5}
然后过滤以保留具有两个不同项的组：
3:{3，-3}，2:{2，-2}
最后，我们应该使用max键：
3
代码：

演示：

结果：

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

您当前的解决方案具有
O（n**2）
时间复杂性，因为该解决方案使用嵌套循环：

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

您可以尝试对时间复杂度
O（n）
进行哈希运算（让它成为LinqC）

给定一个数组，比如说
{3,2，-2,5，-3}
我们可以按绝对值分组：
3:{3，-3}，2:{2，-2}，5:{5}
然后过滤以保留具有两个不同项的组：
3:{3，-3}，2:{2，-2}
最后，我们应该使用max键：
3
代码：

演示：

结果：

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

这个问题可能更适合-但在发布之前。这是家庭作业吗？你自己对时间复杂性的分析是什么？不是家庭作业，而是我正在努力学习的东西（对时间复杂性一无所知）这个问题可能更适合-但在发布之前。这是家庭作业吗？你自己对时间复杂性的分析是什么？不是家庭作业，而是我正在努力学习的东西（对时间复杂性一无所知）这是否适用于重复值l，就像一个数字为3的数组一样，重复两次而不是-3？这就是你添加distinct的原因吗？另外，对于时间复杂性是否有任何保证？我认为group by是在一个未排序的数组上登录的。@Athanasios Kataras:正是我的观点：如果重复
3
而没有
-3
，我们将有一个distin仅ct值。@Athanasios Kataras:由于组未排序，时间复杂度为
O（n）
：纯HashMap/Dictionary@AthanasiosKataras：由于组未排序，时间复杂度为
O（n）
：纯HashMap/Dictionary这是否适用于重复值l，就像一个数字为3的数组一样，两次而不是-3？这就是你添加distinct的原因吗？还有，时间复杂性有什么保证吗？我想group by是在一个未排序的数组上登录的。@Athanasios Kataras：正是我的观点：以防重复
3
和否
>-3
我们将只有一个不同的值。@Athanasios Kataras:因为组没有排序，所以时间复杂度是
O（n）
：纯HashMap/Dictionary@AthanasiosKataras：由于组没有排序，时间复杂度是
O（n）
：纯HashMap/字典
O(n) + O(n) + O(n) + O(1) + O(n) = O(n) 

  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);

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