大厂高频经典面试题(47)-魔术索引

1. 题目：

在数组A[0…n-1]中，有所谓的魔术索引，满足条件A[i] = i。给定一个有序整数数组，元素值各不相同，编写一种方法找出魔术索引，若有的话，在数组A中找出一个魔术索引。

进阶：如果数组元素有重复值，又该如何处理呢？

2. 解题思路：

该问题实际上需要实现包含“元素唯一”和“有重复值”两种情况的解决方案：

case1 - 元素唯一，可以采用二分查找法来实现。

case2 - 元素可能有重复值，可以采用分治法来实现。

3. 图解流程

下面使用多张图，分别演示两种方法（case1和case2）的查找流程，使用以下测试用例：

case1（元素唯一）：[-10, -5, 0, 3, 7]

case2（有重复值）：[-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13]

---

3.1：case1流程图解

图示1：初始状态，第1次二分

初始mid=2，nums[2]=0 < 2 → 搜索右半部分

索引:    0   1   2   3   4
值  : [-10, -5,  0,  3,  7]
         ↑       ↑       ↑
       left     mid     right

图示2：第2次二分后

nums[3]=3 == 3 → 找到魔术索引3

索引: 3   4
值: [ 3,  7]
      ↑   ↑
    left right
      (mid=3)

图示3：返回结果

找到魔术索引：3

---

3.2：case2流程图解

图示1：初始调用

mid=5, nums[5]=3 < 5 → 需要检查左右两部分

索引: 0    1  2   3   4   5   6   7   8   9  10
值: [-10, -5, 2,  2,  2,  3,  4,  7,  9, 12, 13]
      ↑                   ↑                  ↑
     left                mid                right

图示2：搜索左半部分

mid=1, nums[1]=-5 < 1 → 继续搜索当前区间的右半部分

左半部分范围缩小（因nums[5]=3）：
实际检查范围：left=0, right=min(4,3)=3

索引: 0    1   2   3
值: [-10, -5,  2,  2]
      ↑    ↑       ↑
     left mid     right

图示3：当前区间的右半部分

nums[2]=2 == 2 → 找到魔术索引2

索引: 2   3
值: [ 2,  2]
      ↑   ↑
    left right
      (mid=2)

图示4：提前返回

找到第一个魔术索引：2（不再检查右半部分）

---

3.3 关键步骤对比表

步骤	二分查找法	分治法
初始检查	直接比较中间值	比较中间值后需检查两侧
移动方向	严格向左或向右	可能同时搜索左右（但范围优化）
终止条件	nums[mid]==mid	优先返回最早找到的有效结果
时间复杂度	O(log n)	最坏O(n)，平均更好

4. 代码完整实现(C++)：

#include <iostream>
#include <vector>

// 二分查找法（case1）
int findMagicIndexUnique(const std::vector<int>& nums) {
    int left = 0;
    int right = nums.size() - 1;

    while (left <= right) {
        int mid = left + (right - left) / 2;

        if (nums[mid] == mid) {
            return mid;  // 找到魔术索引
        } else if (nums[mid] < mid) {
            left = mid + 1;  // 魔术索引只能在右半部分
        } else {
            right = mid - 1;  // 魔术索引只能在左半部分
        }
    }

    return -1;  // 未找到
}

// 分治法（case2）
int findMagicIndexDuplicateHelper(const std::vector<int>& nums,
                                  int left,
                                  int right) {
    if (left > right) {
        return -1;
    }

    int mid = left + (right - left) / 2;
    int midValue = nums[mid];

    if (midValue == mid) {
        return mid;  // 找到魔术索引
    }

    // 递归搜索左半部分（注意可能的最小范围）
    int leftEnd = std::min(mid - 1, midValue);
    int leftResult = findMagicIndexDuplicateHelper(nums, left, leftEnd);
    if (leftResult != -1) {
        return leftResult;
    }

    // 递归搜索右半部分（注意可能的最小范围）
    int rightStart = std::max(mid + 1, midValue);
    return findMagicIndexDuplicateHelper(nums, rightStart, right);
}

int findMagicIndexDuplicate(const std::vector<int>& nums) {
    return findMagicIndexDuplicateHelper(nums, 0, nums.size() - 1);
}

int main() {
    // 测试元素唯一的情况
    std::vector<int> uniqueNums = {-10, -5, 0, 3, 7};
    std::cout << "唯一元素测试: " << findMagicIndexUnique(uniqueNums)
              << std::endl;  // 输出3

    // 测试有重复元素的情况
    std::vector<int> duplicateNums = {-10, -5, 2, 2, 2, 3, 4, 7, 9, 12, 13};
    std::cout << "重复元素测试: " << findMagicIndexDuplicate(duplicateNums)
              << std::endl;  // 输出2

    return 0;
}

5. 代码分析：

算法说明：

case1 - 二份查找法：

• 时间复杂度：O(log n) —— 使用二分查找
• 空间复杂度：O(1)
• 利用数组有序且元素唯一的特性，通过比较中间值与索引的关系决定搜索方向

case2 - 分治法：

• 时间复杂度：最坏O(n)，但平均优于线性搜索
• 空间复杂度：O(log n) —— 递归调用栈
• 采用分治法，但需要同时搜索左右两部分，因为重复值可能导致魔术索引出现在任意一侧
• 通过std::min和std::max优化搜索范围，跳过不可能的区域

关键点：

• 元素唯一时，可以利用严格的单调性进行二分
• 有重复值时，必须检查左右两部分，但可以适当缩小搜索范围
• 两种实现都返回找到的第一个魔术索引（不保证是最小的）

6. 运行结果：

唯一元素测试: 3
重复元素测试: 2

感谢您的阅读。原创不易，如您觉得有价值，请点赞，关注。