Algorithm 在数组中查找同一元素的两个索引的时间复杂性

我正试图设计一种算法来寻找数组中两个相同元素的索引。输入是一个数组，输出是两个索引i&j，这样数组[i]=array[j]。 时间复杂度必须为O（nlogn）

这是我试过的

let i=0 to size_of_array{
    let j=i+1 to size_of_array{
        if array[j]=array[i]{
            print(i, j)
        }
    }
}

嵌套循环是O（n^2），但如果我尝试这样设计。时间复杂度是多少

n是数组的大小

---

我的实现将运行O（n[（n-1）+（n-2）+（n-3）…+1]）次。它仍然是O（n^2），有人告诉我它是O（nlogn），为什么？

正如您所知，算法的时间复杂度是

O（n^2）

。为了得到更好的结果，可以先对数组排序，然后找到索引

如果对数组进行排序，则具有相同值的两个索引可能位于彼此旁边。因此，您可以迭代排序数组，并报告排序数组中两个当前相邻索引的原始索引

---

排序的时间复杂度可能是

O（n logn）

，然后在数组上迭代是

O（n）

。因此，该算法是

O（nlogn）

您可以保留两个数组：一个带有值（

A

），另一个带有索引（

I

）。一种可能的

O（nlogn）

算法可以是：

将值数组

A

与索引数组

I

并行排序。（时间复杂度：

O（nlogn）

）

扫描

A

并将每个元素与其右邻接元素进行比较，如果发现重复元素，您可以在

I

中返回相应的索引。（时间复杂度：

O（n）

）

我在python函数中实现了这个想法：

import operator

def repeatedNumber(A):
    if len(A) <= 1:
        return -1

    # building the indices array
    indices = range(len(A))

    # join the two arrays
    zipped = zip(A, indices)

    # sort the arrays based on value
    zipped = sorted(zipped, key=operator.itemgetter(0))

    # scan the array and compare every pair of neighbor
    for i in range(len(zipped)):
        if zipped[i][0] == zipped[i + 1][0]:
            return zipped[i][1], zipped[i+1][1]


    return -1

导入操作符
def重复编号（A）：
如果len（A）您可以使用映射进行反向查找

function findSame(theValues) {
  var inverseLookup = {};
  var theLength = theValues.length;
  for (var i = 0; i < theLength; ++i) {
    if (inverseLookup[theValues[i]] != undefined) {
      return ([inverseLookup[theValues[i]], i]);
    }
    inverseLookup[theValues[i]] = i;
  }
  return [];
}

console.log(findSame([1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9]));

函数查找名称（值）{
var inverseLookup={}；
var theLength=值。长度；
对于（变量i=0；i

for
循环有O（n）个时间+
反向查找
有O（1）个时间+O（n）个空间（哈希表）