剑指offer 学习笔记 在排序数组中查找数字

面试题53：在排序数组中查找数字。
1.统计一个数字在排序数组中出现的次数。

解法：在排序数组中使用二分查找算法，直到找到第一个指定数字，之后遍历这个数字的左右两边，直到遍历到非这个数字的值，就可以得到出现次数。但要查找的数字可能在长为n的数组中出现O（n）次，时间复杂度是O（n），太慢了。

改进的解法：我们花费大量时间在确定数字第一次出现的位置和最后一次出现的位置，我们可以直接使用二分查找算法得到首次和最后一次数字出现的位置。在二分查找时，如果第一次查找到该数字，则判断这个数字是不是该数字首次出现，只需判断这个数字之前的数字是不是它本身即可，如不是，在该位置之前继续二分查找，直到找到该数字首次出现的位置。我们可以以同样的思路找到该数字最后一次出现的位置：

#include <iostream>
using namespace std;

int GetFirstK(int* nums, int k, int start, int end) {
    if (start > end) {
        return -1;
    }

    int middleIndex = (start + end) >> 1;
    int middleNum = nums[middleIndex];

    if (middleNum == k) {
        if (middleIndex == 0 || nums[middleIndex - 1] != k) {
            return middleIndex;
        } else {
            end = middleIndex - 1;
        }
    } else if (middleNum < k) {
        start = middleIndex + 1;
    } else {
        end = middleIndex - 1;
    }

    return GetFirstK(nums, k, start, end);
}

int GetLastK(int* nums, int k, int start, int end, int length) {
    if (start > end) {
        return -1;
    }

    int middleIndex = (start + end) >> 1;
    int middleNum = nums[middleIndex];

    if (middleNum == k) {
        if (middleIndex == length - 1 || nums[middleIndex + 1] != k) {
            return middleIndex;
        } else {
            start = middleIndex + 1;
        }
    } else if (middleNum < k) {
        start = middleIndex + 1;
    } else {
        end = middleIndex - 1;
    }

    return GetLastK(nums, k, start, end, length);
}

int GetNumOfK(int* nums, int length, int k) {
    if (nums == nullptr || length <= 0) {
        return 0;
    }
    int first = GetFirstK(nums, k, 0, length - 1);
    int end = GetLastK(nums, k, 0, length - 1, length);

    return end - first + 1;
}

int main() {
    int nums[] = { 0,1,2,3,3,3,4,4,5,6 };
    cout << GetNumOfK(nums, sizeof(nums) / sizeof(*nums), 4) << endl;
}

在数组中以二分法查找指定数字首次出现和最后一次出现的时间复杂度都是O（logn），因此总时间复杂度为O（logn）。

2.一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0~n-1之内，因此，这n个数字中只有一个数字不在数组内，找出这个数字。

法一：用公式求出0~n-1所有数字之和sum，之后把数组中的数字相加并用sum减去该结果，差即为缺失的数字。此方法需要O（n）的时间来求数组中数字的和，并且没有用到数组递增的特性，太慢了。

法二：问题即为求数组中第一个下标与元素值不等的元素，可用二分法：

#include <string>
using namespace std;

int GetMissingNum(int* nums, int length) {
    if (nums == nullptr || length <= 0) {
        return -1;
    }

    int start = 0, end = length - 1, middle = (start + end) >> 1;
    while (start <= end) {
        if (nums[middle] != middle) {
            if (middle == start || nums[middle - 1] == middle - 1) {    // 第一个坐标与元素值不相等的元素，缺失的元素值为坐标值，即middle
                return middle; 
            } else {
                end = middle - 1;
                middle = (start + end) >> 1;
            }
        } else {
            start = middle + 1;
            middle = (start + end) >> 1;
        }
    }
    return -1;
}

int main() {
    int nums[] = { 0,1,2,3,4,5,6,7 };
    int res = GetMissingNum(nums, 9);
    if (res != -1) {
        cout << "缺失的数字为" << res << "。" << endl;
    } else {
        cout << "输入有误" << endl;
    }
}

3.假设一个单调递增的数组里的每个元素都是整数并且是唯一的，找出数组中任意一个数值和下标相等的数字。

法一：从头到尾扫描数组，找出符合题意的元素。时间复杂度为O（n），n为输入数组的长度。

法二：二分查找法，如数字大于下标，说明目标数字在该数字左边，反之在右边：

#include <iostream>
using namespace std;

int GetNumSameAsIndex(int* nums, int length) {
    if (nums == nullptr || length <= 0) {
        return -1;
    }

    int start = 0, end = length - 1, middle = (start + end) >> 1;
    while (start <= end) {
        if (nums[middle] == middle) {
            return middle;
        } else if (nums[middle] > middle) {
            end = middle - 1;
            middle = (start + end) >> 1;
        } else {
            start = middle + 1;
            middle = (start + end) >> 1;
        }
    }
    return -1;
}

int main() {
    int nums[] = { -1,0,1,3,5,6 };
    int res = GetNumSameAsIndex(nums, sizeof(nums) / sizeof(*nums));
    if (res >= 0) {
        cout << "与下标相等的元素值为" << res << "。" << endl;
    } else {
        cout << "输入错误。" << endl;
    }
}