查找是否存在任何 i 使得 array[i] 等于 i 的算法

Question

我的 CS 教授给我一个作业：

在 O(logn) 时间内找到，如果在给定的不同整数的预排序数组中存在索引 i，则 array[i] = i。证明时间是O(logn)。

更新：整数可以是负数、0 或正数。

好的，所以我在这方面有点挣扎。我的想法是这样的：

使用二分查找，如果array[mid]

数组右半部分对应的规则是array[mid] >= startindex + numel，其中变量如上，numel为mid右边的元素个数。

这看起来不像 O(logn)，因为在最坏的情况下我必须遍历整个事情，对吗？有人可以在这里提示我正确的方向，或者告诉我这行得通吗？

有什么想法可以正式证明这一点吗？我不是要求一个明确的答案，更多的是帮助我理解。

在 C 中：

int _solve_prob_int(int depth, int start, int count, int input[])
    {
    if(count == 0)
        return 0;
    int mid = start + ((count - 1) / 2);
    if(input[mid] == mid)
        return 1;

    if(input[mid] <= start && input[mid] >= start + count)
        return 0;

    int n_sub_elleft = (int)(count - 1) / 2;
    int n_sub_elright = (int)(count) / 2;

    if(input[mid] <= start)
        return _solve_prob_int(depth + 1, mid + 1, n_sub_elright, input);

    if(input[mid] >= start + count)
        return _solve_prob_int(depth + 1, mid - n_sub_elleft, n_sub_elleft, input);

    return _solve_prob_int(depth + 1, mid - n_sub_elleft, n_sub_elleft, input) ||
            _solve_prob_int(depth + 1, mid + 1, n_sub_elright, input);
    }

一个测试用例：

Sorted args: 1 2 3 4 5 6 7 8 9 10 11 12 : 
Start: 0, count: 12, mid: 5 value: 6
    Start: 0, count: 5, mid: 2 value: 3
        Start: 0, count: 2, mid: 0 value: 1
            Start: 1, count: 1, mid: 1 value: 2
        Start: 3, count: 2, mid: 3 value: 4
            Start: 4, count: 1, mid: 4 value: 5
    Start: 6, count: 6, mid: 8 value: 9
        Start: 6, count: 2, mid: 6 value: 7
            Start: 7, count: 1, mid: 7 value: 8
        Start: 9, count: 3, mid: 10 value: 11
            Start: 9, count: 1, mid: 9 value: 10
            Start: 11, count: 1, mid: 11 value: 12

以上是我的程序根据搜索方式运行的一些输出。对于从 1 到 12 的列表，它围绕索引 5 旋转，确定索引 0-4 处可能存在 0-4 之间的值。它还确定索引 6-11 处可能存在 6-11 之间的值。因此，我继续搜索它们。这是错的吗？

Answer 1

整数是不同的且已排序。

给定我这样array[i] = i 你有array[i] - i = 0。

对于每个 j array[j] - j <= 0 并且对于 j > i 你有 array[j] - j >= 0 因为 j 在每一步变化为 1 但 array[j] 变化至少为 1（不同的和排序的数字）。

所以左边是<=0，右边是>= 0。

使用二分法，您可以在O(log n) 中轻松找到正确的位置。

---

请注意，您只需要找到一个元素，而不是所有元素。在您的示例中，所有元素都可以正常工作，但您只需要其中一个。如果你想全部打印出来，那就是O(n)..

Answer 2

将二进制搜索想象为在字典中查找单词。您可以先将书准确地打开到字典的中心，然后查看页面顶部的单词是在您要查找的单词之前、之后还是等于您要查找的单词。如果是在之后，则将字典的后半部分一分为二并检查该半部分的中间部分。查看页面顶部后，您已将要搜索的区域缩小到字典的四分之一以内。你继续这个过程，直到你发现这个词在你正在查看的页面上的某个地方。然后，您使用类似的过程在该页面上查找单词。

这个过程不是 O(n)，因为您不必查看每一页上的每个单词，即使在最坏的情况下也是如此。这是 O(log n)，因为在每一步中，您都能够消除大约一半的字典，因为 not 包含您要查找的单词。

编辑

对不起，我误解了原来的问题。

在这种情况下，关键是要认识到所谓的“皮江孔原理”，它指出您只能将尽可能多的皮江放入孔中。（留给学术界为这样一个简单的想法想出一个名字！）

考虑以下情况：

0 1 2 3 4 5 6

这里，所有array[i]等于i，所以当你第一次开始你的二分搜索时，你会立即得到一个肯定的答案。

现在让我们从底部取一个数字：

0 1 3 4 5 6

当您进行二分搜索时，您会发现array[3] > 3，并且您可以正确推断出高于该枢轴点的任何值都不可能成为array[i] == i。这是因为列表是有序且唯一的，因此您不能以这样的组合结束：

0 1 3 4 5 5 6
0 1 3 4 6 5 7

一旦确定array[i] 大于i，i 和任何给定的n 之间就没有足够的数字来允许数组中的下一个元素更接近i .同样，如果您确定 array[i] 小于 i，则当您查看数组的开头时，您没有足够的“间隙”来“赶上”i。

因此，在每一步中，您都可以正确消除数组的一半，并且就像在字典中查找一样，在 O(log n) 时间内确定是否有 array[i] == i。

Answer 3

这是一个二分查找问题没有给出键。在 OP 的问题中，关键是 mid 本身！就是这样，在每个子数组中搜索中间元素。

使用二进制搜索的解决方案的伪代码：

    while (low and high don't meet)
        mid = (low + high) / 2
        if (arr[mid] < mid)
            high = mid - 1
        else if (arr[mid] > mid)
            low = mid + 1
        else // we found it!
            return mid;
    // end while
    return -1; // indicates there is no such i

Answer 4

你的直觉是正确的使用二分搜索；你的分析不是。请记住，它是一个排序列表，因此在二进制搜索条件下，您需要搜索 MAXIMUM 个 log(n) 条目。

Answer 5

我会尽量不泄露答案，但我会指出一些观察结果：

检查中间元素时，有3种情况。第一个当然是array[i] == i，在这种情况下算法终止。在其他两种情况下，我们能够丢弃元素本身以及大约一半的输入。

现在，如果 array[i] > i，当我们向右移动时，数组索引 (i) 是否有可能“赶上”数组值？请记住数组值的排序不同的属性。

Answer 6

因为数组 A 已排序。 A[i]>=A[i-1]+1 => A[i]-i >= A[i-1]-(i-1)，令 B[i] = A[i]-i， B[] 是一个排序数组，可以使用二进制搜索在 lgn 时间内搜索到 B[x]==0。

Answer 7

Array B[i] = A[i]-i 可能无法排序，即使 A[i] 已排序但有重复项：

考虑这个例子：

我：0 1 2 3 4
答：1 1 2 4 4

B[0] = A[0]-0 = 1, B[1] = A[1] -1 = 0 , ...

B：1 0 0 1 0

Answer 8

public static int fixedPoint(int[] array, int start, int end) {

    if (end < start || start < 0 || end >= array.length) {
        return -1;
    }
    int midIndex = start +(end-start)/ 2;
    int midValue = array[midIndex];
    if (midValue == midIndex) {//trivial case
        return midIndex;
    }
    // if there are duplicates then we can't conclude which side (left or right) will
    // have the magic index. so we need to search on both sides
    //but, we can definitely exclude few searches.
    // take the example of the array : 
    //   0   1  2  3  4  5                        6  7  8  9   10 -> indices
    // -10, -5, 2, 2, 2, 3(midVal, midIndex = 5), 4, 7, 9, 12, 13 -> array element
    // here, midValue < midIndex, but we can't say for sure which side to exclude
    // as you can see there are two such magic indices. A[2] = 2 and A[7] = 7. so
    // we need to search both sides
    // since midValue < midIndex, then we can be sure that between index can't be
    // between index number midValue and midIndex-1

    /* Search left */
    int leftIndex = Math.min(midIndex - 1, midValue);
    int left = fixedPoint(array, start, leftIndex);
    if (left >= 0) {
        return left;
    }

    /* Search right */
    int rightIndex = Math.max(midIndex + 1, midValue);
    int right = fixedPoint(array, rightIndex, end);

    return right;
}

public static int fixedPoint(int[] array) {
    return fixedPoint(array, 0, array.length - 1);
}

Answer 9

输入：排序后的 n 个不同整数的数组 A，可以是正数、负数或零。

输出：如果有一个索引i满足A[i] = i，则返回True，否则返回False。

运行时间：O(logN)

---

分而治之的策略用于通过使用名为midpoint的变量将数组减半来将数组划分为子数组。目标是递归地将数组分成两个分支，直到两个分支中的每一个中都剩下一个元素。

当通过比较低点和中点索引找到单个元素时，对左分支和右分支进行 A[i] = i 的评估。只要两个分支之一为True，程序就结束。

在递归情况下：

return False or True  -> True
return False or False -> False
return True or  ----- -> True // Short-circuit operator: regardless of the right branch, the result will be True.

这段 Python 代码可以很容易地用 C 或任何其他语言编写：

def isIndex(A, low, high):
    midpoint = int( (low + high)/2 )
    if low == midpoint:
        # base case
        print("Left-> low: %d, A[low]: %d. Right-> high: %d, A[high]: %d" % (low, A[low], high, A[high]))
        return low == A[low] or high == A[high]
    else:
        # recursive case
        return isIndex(A, low, midpoint-1) or isIndex(A, midpoint, len(A)-1)

A = [0, 1, 3, 5]
print(isIndex(A, 0, len(A)))
"""
Left-> low: 0, A[low]: 0. Right-> high: 1, A[high]: 1
True
"""

A = [-1, 0, 1, 3, 9, 10]
print(isIndex(A, 0, len(A)))
"""
Left-> low: 0, A[low]: -1. Right-> high: 0, A[high]: -1
Left-> low: 1, A[low]: 0. Right-> high: 2, A[high]: 1
Left-> low: 3, A[low]: 3. Right-> high: 3, A[high]: 3
True
"""