数组中最频繁和最不频繁元素之间的最小距离

在一个数组中，找到任何最频繁和最不频繁的元素之间的最小距离是一个常见的问题，通常也是面试中的常考题目之一。解决这个问题需要一定的算法技巧，本文将提供两种不同的解决方法，供大家参考。

方法一：哈希表

使用哈希表可以非常方便地统计每个元素的出现次数，并且可以一次遍历数组就完成这个过程。具体步骤如下：

1. 遍历整个数组，记录每个元素出现的次数，将其存入哈希表中。
2. 找到出现次数最多和出现次数最少的元素。
3. 创建一个大小为两个元素出现次数之和的数组，将其中一个元素放在数组中心，然后从两个元素向数组两端扩展。
4. 在数组中寻找最小距离，即可得到答案。

以下是具体的python实现：

import collections

def min_distance(arr):
    # 统计元素出现次数
    cnt = collections.Counter(arr)
    # 找到出现次数最多和最少的元素
    max_num, min_num = cnt.most_common()[-1][1], cnt.most_common()[0][1]
    max_elem, min_elem = [], []
    for i in cnt:
        if cnt[i] == max_num:
            max_elem.append(i)
        if cnt[i] == min_num:
            min_elem.append(i)
    # 创建含有最大和最小元素的数组
    start, end = min_elem[0], max_elem[0]
    dist = [0] * (cnt[start] + cnt[end])
    mid = len(dist) // 2
    dist[mid] = start
    idx = mid + 1
    for i in range(cnt[start] - 1):
        dist[idx] = start
        idx += 1
    dist[mid - 1] = end
    idx = mid - 2
    for i in range(cnt[end] - 1):
        dist[idx] = end
        idx -= 1
    # 在数组中查找最小距离
    min_dist = float("inf")
    for i in range(len(dist) - 1):
        if dist[i] in (start, end) and dist[i + 1] in (start, end):
            continue
        if dist[i] == start or dist[i] == end:
            min_dist = min(min_dist, abs(i - mid))
    return min_dist

方法二：排序

另一种解决方法是先将数组排序，然后从前往后遍历，记录当前元素出现的次数以及上一次最少出现次数的元素的下标，再从后往前遍历，也记录当前元素出现的次数以及上一次最多出现次数的元素的下标。最后遍历完成后，我们就可以在上述两个下标位置之间找到最小距离。

以下是具体的python代码实现：

def min_distance(arr):
    arr.sort()
    min_elem, max_elem = arr[0], arr[0]
    min_num, max_num = len(arr), 1
    prev_min_idx, prev_max_idx = -1, -1
    for i in range(len(arr)):
        if arr[i] == min_elem:
            if prev_min_idx != -1:
                min_distance = i - prev_min_idx
                if min_distance < min_num:
                    min_num = min_distance
            prev_min_idx = i
        if arr[i] == max_elem:
            if prev_max_idx != -1:
                max_distance = i - prev_max_idx
                if max_distance > max_num:
                    max_num = max_distance
            prev_max_idx = i
        if arr[i] != arr[i - 1]:
            if i - prev_min_idx < min_num:
                min_num = i - prev_min_idx
                min_elem = arr[i - 1]
            if i - prev_max_idx > max_num:
                max_num = i - prev_max_idx
                max_elem = arr[i - 1]
    return min_num

两种方法的时间复杂度均为O(nlogn)，但方法一的常数较大，因为需要使用哈希表。方法二可能需要对数组进行排序，但比方法一节省一些额外常数。无论哪种方法，都可以在常数级别上达到优化。