求助：如何查找数组中各元素的下一最近最大数

嘿，我懂你现在的困扰了——你之前用嵌套循环实现的是下一个更大元素（也就是当前元素之后第一个比它大的数），但现在需要的是整个数组里最接近当前元素的更大数（说白了就是所有比它大的数里最小的那个），对吧？咱们一步步来解决这个问题。

先明确核心要求：

• 对数组中的每个元素，找到所有比它大的元素里数值最小的那个（这就是最接近它的更大数）
• 如果当前元素是数组的最大值，返回Integer.MAX_VALUE

举个例子，比如数组里的42，比它大的数有56、50、100、60，其中最小的是50，所以对应输出42 : 50，和你给的示例一致。

既然你之前用的是嵌套循环，那咱们直接修改这个思路就行——不再只遍历当前元素之后的部分，而是遍历整个数组，记录所有比当前元素大的数里的最小值。

代码示例（Java）：

public class ClosestGreaterFinder {
    public static void main(String[] args) {
        int[] numbers = {12, 42, 13, 56, 41, 50, 100, 60};
        
        for (int current : numbers) {
            // 初始化最接近的更大数为MAX_VALUE，表示暂时没找到
            int closestGreater = Integer.MAX_VALUE;
            
            // 遍历整个数组找符合条件的数
            for (int num : numbers) {
                if (num > current) {
                    // 如果当前num比current大，并且比已找到的closestGreater更小，就更新
                    if (num < closestGreater) {
                        closestGreater = num;
                    }
                }
            }
            
            // 输出结果
            if (closestGreater == Integer.MAX_VALUE) {
                System.out.println(current + " : MAX_VALUE");
            } else {
                System.out.println(current + " : " + closestGreater);
            }
        }
    }
}

运行这段代码，就能得到你预期的输出：

12 : 13
42 : 50
13 : 41
56 : 60
41 : 42
50 : 56
100 : MAX_VALUE
60 : 100

如果数组很大，嵌套循环的O(n²)时间复杂度会有点慢。咱们可以先把数组排序，然后用二分查找快速定位到第一个比当前元素大的数，这样时间复杂度能降到O(n log n)。

代码示例（Java）：

import java.util.Arrays;

public class ClosestGreaterOptimized {
    public static void main(String[] args) {
        int[] numbers = {12, 42, 13, 56, 41, 50, 100, 60};
        // 复制原数组并排序
        int[] sortedNumbers = Arrays.copyOf(numbers, numbers.length);
        Arrays.sort(sortedNumbers);
        
        for (int current : numbers) {
            int index = Arrays.binarySearch(sortedNumbers, current);
            
            // 处理二分查找的返回值：没找到的话，返回的是-(插入点)-1
            if (index < 0) {
                index = -index - 1;
            } else {
                // 如果有重复元素，要跳过所有和current相等的元素，找到第一个比它大的
                while (index < sortedNumbers.length && sortedNumbers[index] == current) {
                    index++;
                }
            }
            
            int closestGreater;
            // 如果index超出数组长度，说明current是最大值
            if (index >= sortedNumbers.length) {
                closestGreater = Integer.MAX_VALUE;
            } else {
                closestGreater = sortedNumbers[index];
            }
            
            // 输出结果
            System.out.println(current + " : " + (closestGreater == Integer.MAX_VALUE ? "MAX_VALUE" : closestGreater));
        }
    }
}

你之前的嵌套循环应该是只遍历了当前元素之后的元素，找第一个比它大的数（也就是下一个更大元素），但这个需求是要在整个数组里找所有比它大的数中的最小值，所以范围从“当前元素之后”变成了“整个数组”，逻辑也就不一样啦。

内容的提问来源于stack exchange，提问作者brett