面试问题 - 在排序数组 X 中搜索索引 i 使得 X[i] = i

Question

昨天我在面试中被问到以下问题：

考虑一个 Java 或 C++ 数组，比如 X，它已排序并且其中没有两个元素是相同的。如何最好地找到一个索引，比如i，这样该索引处的元素也是i。那是X[i] = i。

作为澄清，她还给了我一个例子：

Array X : -3 -1 0 3 5 7
index   :  0  1 2 3 4 5

Answer is 3 as X[3] = 3.

我能想到的最好的方法是线性搜索。面试后我虽然对这个问题说了很多，但找不到更好的解决方案。我的论点是：具有所需属性的元素可以在数组中的任何位置。所以它也可能在数组的最后，所以我们需要检查每个元素。

我只是想从这里的社区确认我是对的。请告诉我我是对的:)

Answer 1

这可以在O(logN) 时间和O(1) 空间中通过使用稍作修改的binary search 来完成。

考虑一个新数组Y，这样Y[i] = X[i] - i

Array X : -3 -1   0  3  5  7
index   :  0  1   2  3  4  5
Array Y : -3 -2  -2  0  1  2

由于X 中的元素是递增 顺序的，所以 新数组 Y 将按 非递减 顺序排列。所以一个二进制 在Y 中搜索 0 将给出答案。

但是创建Y 将占用O(N) 空间和O(N) 时间。所以而不是 创建新数组，您只需修改二进制搜索，以便 对Y[i] 的引用被X[i] - i 替换。

算法：

function (array X) 
       low  = 0
       high = (num of elements in X) - 1

       while(low <= high) 
               mid = (low + high) / 2

               // change X[mid] to X[mid] - mid
               if(X[mid] - mid == 0)
                       return mid

               // change here too
               else if(X[mid] - mid < 0)
                       low = mid + 1;

               else
                       high = mid - 1;
       end while

       return -1 // no such index exists...return an invalid index.

end function

Java implementation

C++ implementation

Answer 2

有一些更快的解决方案，平均 O(log n) 或在某些情况下 O(log log n) 而不是 O(n)。 “二分搜索”和“插值搜索” google，你可能会找到很好的解释。

如果数组是未排序的，那么是的，元素在任何地方，你不能低于 O(n)，但排序数组不是这种情况。

--

根据要求对插值搜索进行一些解释：

虽然二分搜索只涉及比较两个元素的“更大/不更大”，但插值搜索也尝试使用数值。关键是：您有一个从 0 到 20000 的排序范围。您寻找 300 - 二分搜索将从范围的一半开始，即 10000。插值搜索猜测 300 可能更接近 0大于 20000，因此它将首先检查元素 6000 而不是 10000。然后再次 - 如果它太高，则递归到较低的子范围，并且它太低 - 递归到上部子范围。

对于具有 +- 均匀分布值的大数组，插值搜索应该比二分搜索快得多 - 编写代码并自己查看。 此外，如果首先使用一个插值搜索步骤，然后使用一个二分搜索步骤，以此类推，效果最好。

请注意，这是人类在字典中查找内容时的直觉行为。

Answer 3

它不需要按照@codaddict 在answer 中的建议考虑任何数组Y。

使用二分查找并检查给定数组的中间元素，如果它低于它的索引，我们不需要检查任何更低的索引，因为数组是 已排序，因此如果我们向左移动，减去 m 个索引和（至少）m 个值，所有后续元素也将太小。例如。如果arr[5] = 4 然后arr[4] <= (4 - 1) 和arr[3] <= (4 - 2) 等等。如果中间元素大于其索引，则可以应用类似的逻辑。

这里是简单的Java 实现：

int function(int[] arr) {
        int low = 0;
        int high = arr.length - 1;

        while(low <= high) {
            int mid = high - (high - low) / 2;

            if(arr[mid] == mid) {
                 return mid;
            } else if(arr[mid] < mid) {
                 low = mid + 1;
            } else {
                 high = mid - 1;
            }
        }

        return -1; // There is no such index
}

请注意，仅当所有元素都不同时，上述解决方案才有效。

Answer 4

我认为这会更快。

从列表中间开始

如果 X[i] > i 则走到剩下的左边的中间

如果 X[i]

继续这样做，它会将每个循环的可能元素数量减少一半

Answer 5

您可以执行二分搜索： 搜索中间，如果该值低于索引，则没有更低的索引将包含相同的值。

然后你搜索上半部分，并继续直到找到元素，或者达到一个元素跨度。

Answer 6

这是我想出的一个解决方案，如果有重复，它就可以工作（我错误地忽略了没有重复的警告）。

//invariant: startIndex <= i <= endIndex

int modifiedBsearch(int startIndex, int endIndex)
{
   int sameValueIndex = -1;
   int middleIndex = (startIndex + endIndex) /2;
   int middleValue = array[middleIndex];
   int endValue = array[endIndex];
   int startValue = array[startIndex];

   if(middleIndex == middleValue)
      return middleValue;
   else {
      if(middleValue <= endIndex)
         sameValueIndex = modifiedBsearch(middleIndex + 1, endIndex)

      if(sameValueIndex == -1 && startValue <= middleIndex)
         sameValueIndex = modifiedBsearch(startIndex, middleIndex -1);
   }

   return sameValueIndex;

}

我猜这需要 O(log n) 时间，但乍一看并不清楚？？？

如果运气不好，会花费 O(n log n) 时间（堆栈树的高度为 log n，它会是一棵完整的树，最后一层有 n 个节点，n/ 2 在倒数第二，等等）。

因此，平均而言，它将介于 O(log n) 和 O(n log n) 之间。

Answer 7

在我的脑海中，进行二进制拆分可能会更快。

看中间值，如果高那么你需要的，在下半部分重新搜索。

经过一次比较，您已经将数据集分成了一半

Answer 8

阅读问题后，似乎有一种情况可用于加快查找速度。在将位置与值进行比较时，如果值大于该位置，则该值可以用作下一个要评估的位置。这将有助于更快地跳过数组。可以这样做，因为数组已排序。我们正在跳过的值在概念上被移到数组的左侧并且位于错误的位置。

例子：

int ABC[] = { -2, -5, 4, 7, 11, 22, 55 };

如果我当前的位置是 2，它的值是 4，它们不相等，从概念上讲，值 4 向左移动。我可以将 4 的值用作我的下一个位置，因为如果值 4 不在位置上，那么小于 4 的所有东西也都不在位置上。

一些示例代码仅供讨论：

void main()
{
    int X[] = { -3, -1, 0, 3, 5, 7};
    int length = sizeof(X)/sizeof(X[0]);

    for (int i = 0; i < length;) {
        if (X[i] > i && X[i] < length)
            i = X[i];                 // Jump forward!
        else if (X[i] == i) {
            printf("found it %i", i);
            break;
        } else
            ++i;
    }
}

Answer 9

我猜修改版的二分搜索就足够了

假设序列是

Array : -1 1 4 5 6
Index :  0 1 2 3 4

Result : 1

或

Array : -2 0 1 2 4 6 10
Index :  0 1 2 3 4 5 6 

Result: 4

从这两个示例中我们看到，如果 mid

mid <- (first + last )/2

if a[mid] == mid then
       return mid

else if a[mid] < mid then
        recursive call (a,mid+1,last)

else 
         recursive call (a,first,mid-1)

Answer 10

Java：

public static boolean check (int [] array, int i)
{
    if (i < 0 || i >= array.length)
        return false;

    return (array[i] == i);
}

C++：

bool check (int array[], int array_size, int i)
{
    if (i < 0 || i >= array_size)
        return false;

    return (array[i] == i);
}