以最佳时间复杂度 [Java] 在未排序的整数数组中找到两个相同数字之间的最大差异

Question

static int solution(int[] A) {
    int N = A.length;
    int result = 0;
    Map<Integer, List<Integer>> map = new TreeMap<>();
    for (int i = 0; i < N; i++) {
        List<Integer> list = map.getOrDefault(A[i], new ArrayList<>());
        list.add(i);
        map.put(A[i], list);

    }
    for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
        List<Integer> list = map.get(entry.getKey());
        Collections.sort(list);
        result = Math.max(result, (list.get(list.size() - 1) - list.get(0)));
    }
    return result;
}

通过上述解决方案，我们可以解决问题，但它不是 O(N) 时间复杂度。 所以我在Java中寻找这个问题的优化解决方案。

Answer 1

// Collections.sort(list);//去掉这一行使得O(NlogK)到O(N)的时间复杂度

  static int solution(int[] A) {
    int N = A.length;
    int result = 0;
    Map<Integer, List<Integer>> map = new HashMap<>();
    for (int i = 0; i < N; i++) {
        List<Integer> list = map.getOrDefault(A[i], new ArrayList<>());
        list.add(i);
        map.put(A[i], list);

    }
    for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
        List<Integer> list = map.get(entry.getKey());
        result = Math.max(result, (list.get(list.size() - 1) - list.get(0)));
    }
    return result;
}

Answer 2

解决方案之一是遍历所有元素并仅跟踪第一次和最后一次出现，如下所示：

class Pair<F, S> {
    F first;
    S second;
    constrcutor(F first, S second) {
        this.first = first;
        this.second = second;
    }
}

    static int solution(int arr[]) {

        // Pair.first will contain the first occurrence and Pair.second will contain the last occurrence of number
        HashMap<Integer, Pair<Integer, Integer>> minMaxMap = new HashMap<>();
        for (int index = 0; index < arr.length; index++) {
            Pair<Integer, Integer> existingValue = minMaxMap.get(arr[index]);
            if (existingValue == null) {
                minMaxMap.put(arr[index], new Pair<Integer, Integer>(index, index));
            } else {
                existingValue.second = index; // update the Pair.second to latest value.
            }
        }

        int result = 0;
        for (Pair<Integer, Integer> pair : minMaxMap.values()) {
            int difference = pair.second - pair.first;
            if (difference > result) {
                result = difference;
            }
        }
        return result;
    }

在您的解决方案中，由于我们使用的是列表，因此需要更多 memory 以防数组包含大量重复元素。 通过避免列表，您甚至可以减少 memory 的占用空间。

Answer 3

我认为这看起来是一个有效的解决方案——它不使用任何 collections 并且不需要遍历所有值。 它检查最大距离处的对（数组两端的数字相同），然后是最大距离 - 1 等等，直到找到对为止。

static int solution(int[] A) {
    for (int i = 0; i < A.length; i++) {
        for (int j = 0; j < i; j++) {
            if (A[j] == A[j + A.length - i])
                return A.length - i;
        }
    }
    return -1; //-1 stands for no equal numbers
}