Algorithm 求数组中等数最小索引差的算法

有人知道如何解决下一个问题吗：

例如，我们有一个数组，让它成为 a={1,0，-1，-2，-1,0,1,2,3,4,5,1}

算法应该找到相同数字的索引之间最小差异的大小。 在本例中（数组a），1的指数之差为6-0=0和11-6=5，0的指数之差为5-1=4，负1的指数之差为4-2=2，依此类推。 算法应该返回2，因为我们可以看到它是相同数字的指数的最小差值

---

有没有比O（n^2）更好的时间复杂度解决这个问题的方法

以下算法将在

O（nlogn）

---

这里我们可以看到，3-1=2将给出索引的最小差异。

这是用Go编程语言编写的

func smallestIndexDifference(numbers []int) (mindiff int, exists bool) {
  var prev map[int]int // The previous index where this number was found
  for i, number := range numbers {
    prevIndex, found := prev[number]
    if found {
      diff := i - prevDiff
      if !exists || diff < mindiff {
        exists, mindiff = true, diff
      }
    }
    prev[number] = i
  }
  return
}

func smallestIndexDifference（number[]int）（mindiff int，exists bool）{
var prev map[int]int//找到此数字的上一个索引
对于i，编号：=范围编号{
找到的prevIndex:=prev[编号]
如果找到{
diff:=i-prevDiff
如果！存在| | diff

这是完全未经测试的，但如果它能工作，它在O（n log n）中工作。

Make

vector

，它将存储原始向量的值及其各自的索引。对于索引为i的每个值v，将（v，i）添加到向量

对向量进行排序（先按值，然后按索引）

然后遍历排序向量，找到相同值元素之间的最小（或最大，如果需要）距离

---

这需要O（n logn）步骤。

其他几个答案建议排序（元素、索引）对，可以在O（n*logn）中完成。然而，只要O（n）时间，就可以做得更好。不需要对数组进行排序，也不需要保留所有（元素、索引）对，因为可以贪婪地找到最小值

循环遍历数组一次，并将每个元素的最后一个索引存储在散列中

int smallestDifference(int[] a) {
    Map<Integer, Integer> lastIndex = new HashMap<>();
    int minDiff = Integer.MAX_VALUE;
    for (int i = 0; i < a.length; i++) {
        if (lastIndex.contains(a[i])) {
            minDiff = Math.min(minDiff, i - lastIndex.get(a[i]));
        }
        lastIndex.put(a[i], i);
    }
    return minDiff;
}

int最小差异（int[]a）{
Map lastIndex=new HashMap（）；
int minDiff=Integer.MAX_值；
for（int i=0；i

---

Insert/get from hash为O（1），因此整个数组的值为O（n）。

首先，可以将索引添加到序列中（O（n））：

>L=[1,0，-1，-2，-1,0,1,2,3,4,5,1]。
[1,0,-1,-2,-1,0,1,2,3,4,5,1]
>LI=列表：zip（L，列表：seq（1，长度（L）））。
[{1,1},
{0,2},
{-1,3},
{-2,4},
{-1,5},
{0,6},
{1,7},
{2,8},
{3,9},
{4,10},
{5,11},
{1,12}]

然后对其进行排序（O（N log N））：

LS=列表：排序（LI）。 [{-2,4}, {-1,3}, {-1,5}, {0,2}, {0,6}, {1,1}, {1,7}, {1,12}, {2,8}, {3,9}, {4,10}, {5,11}] 然后找到所有相同值的距离（O（N））：

>LD=（funf（[{X，P1}|[{X，P2}||]=T]）->[{P2-P1，X，{P1，P2}}}}F（T）]；F（[]）->F（T）；F（[]）->end（LS）。
[{2,-1,{3,5}},{4,0,{2,6}},{6,1,{1,7}},{5,1,{7,12}}]

然后找到最小距离（O（N））：

>列表：最小值（LD）。
{2,-1,{3,5}}

---

这意味着位置3和位置5之间的最小距离为-1，结果复杂度为O（N logn）。（示例代码是Erlang。）

你不应该相信他们在学校教给你的一切。实际上，从散列中插入/获取不是O（1）。试着想一想。您认为1T密钥的哈希访问时间与1k密钥相同吗？真正地这很幼稚。你是对的，从一个散列库中获得这样的性能是相当了不起的，但这是可能的。然而，居高临下的语气对你的情况几乎没有帮助。这不是我的情况，这是现实，处理它吧。散列从来都不是O（1），今天更糟。想提供证据吗？请扩展您的答案，然后，为什么这个方法不起作用，提供一些证据。这个方法会起作用，但肯定不是O（N）。充其量只能是O（N logn）。

func smallestIndexDifference(numbers []int) (mindiff int, exists bool) {
  var prev map[int]int // The previous index where this number was found
  for i, number := range numbers {
    prevIndex, found := prev[number]
    if found {
      diff := i - prevDiff
      if !exists || diff < mindiff {
        exists, mindiff = true, diff
      }
    }
    prev[number] = i
  }
  return
}

int smallestDifference(int[] a) {
    Map<Integer, Integer> lastIndex = new HashMap<>();
    int minDiff = Integer.MAX_VALUE;
    for (int i = 0; i < a.length; i++) {
        if (lastIndex.contains(a[i])) {
            minDiff = Math.min(minDiff, i - lastIndex.get(a[i]));
        }
        lastIndex.put(a[i], i);
    }
    return minDiff;
}