二分查找的递归和非递归实现，二分查找的扩展

凡是有序数组中的查找问题，都应该联系二分查找解决

1. 递归实现

// 递归二分查找
int BinarySearch(int nums[], int left, int right, int key) {
    if (left > right) {
        return -1;
    }
    int mid = left + ((right - left) >> 1);
    if (nums[mid] == key) {
        return mid;
    } else if (nums[mid] > key) {
        return BinarySearch(nums, left, mid - 1, key);
    } else {
        return BinarySearch(nums, mid + 1, right, key);
    }
}

2. 非递归实现

// 迭代二分查找
int BinarySearch2(int nums[], int left, int right, int key) {
    int mid;
    while (left <= right) {
        mid = left + (right - left) / 2;
        if (nums[mid] == key) {
            return mid;
        } else if (nums[mid] > key) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1;
}

3. 在一个有序数组中查找某个元素出现的次数

有两种可能的数据，可以对应两种解决算法。
相关问题：数字在排序数组中的次数
假设在数组中 nums[] 中查找元素 key

• 情况一： 每一个元素出现的次数比较均衡：用普通二分查找找到 key 的位置，从该位置分别向两侧统计该key出现的次数
• 情况二： 如果数组中的元素出现次数是不均衡的，如某一个元素可能出现的次数接近 n 次，那么如果用上一种算法，复杂度退化为O(n). 我们可以用二分查找的方法查找 key 第一次和最后一次出现的位置。

对于第二种情况，用二分查找 key 第一次和最后一次出现的位置，和普通二分查找唯一不同在于：
当查找到 nums[mid] == key 时

• 第一次出现key的位置：只有当到达最左端或者前一个节点不等于 key 时才结束查找；否则继续向左查找；
• 最后一次出现key的位置：只有当到达最右端或者前一个节点不等于 key 时才结束查找；否则继续向右查找；

第二种情况源码实现：

// 方法二
// 如果重复的数字占据数组的比例很大时，如果用上述方法则复杂度为O(n)
// 因此采用二分查找第一个key和最后一个key
int GetFirstKey(int nums[], int left, int right, int key);
int GetLastKey(int nums[], int left, int right, int key);

int CountTimes2(int nums[], int left, int right, int key) {
    int fistK = GetFirstKey(nums, left, right, key);
    int lastK = GetLastKey(nums, left, right, key);
    if (fistK < 0 || lastK < 0)
        return 0;
    return lastK - fistK + 1;
}
int GetFirstKey(int nums[], int left, int right, int key) {
    if (left > right)
        return -1;
    int mid = left + (right - left) / 2;
    if (nums[mid] == key) {
        // 和普通二分查找唯一不同处：只有当到达最左（右）端或者前一个节点不等于key时才结束查找
        if (mid == left || nums[mid - 1] != key)
            return mid;
        else
            return GetFirstKey(nums, left, mid - 1, key); // 继续向左查找
    } else if (nums[mid] > key) {
        return GetFirstKey(nums, left, mid - 1, key);
    } else {
        return GetFirstKey(nums, mid + 1, right, key);
    }
}
int GetLastKey(int nums[], int left, int right, int key) {
    if (left > right)
        return -1;
    int mid = left + (right - left) / 2;
    if (nums[mid] == key) {
        if (mid == right || nums[mid + 1] != key)
            return mid;
        else
            return GetLastKey(nums, mid + 1, right, key);// 继续向右查找
    } else if (nums[mid] > key) {
        return GetLastKey(nums, left, mid - 1, key);
    } else {
        return GetLastKey(nums, mid + 1, right, key);
    }
}

4. 所有源码实现

#include <iostream>
#include <algorithm>
using namespace std;

template<class T, size_t len>
void PrintArray(const T(&a)[len]) {
    for (int i = 0; i < len; i++)
        cout << a[i] << " ";
    cout << endl;
}
// 递归二分查找
int BinarySearch(int nums[], int left, int right, int key) {
    if (left > right) {
        return -1;
    }
    int mid = left + ((right - left) >> 1);
    if (nums[mid] == key) {
        return mid;
    } else if (nums[mid] > key) {
        return BinarySearch(nums, left, mid - 1, key);
    } else {
        return BinarySearch(nums, mid + 1, right, key);
    }
}
// 迭代二分查找
int BinarySearch2(int nums[], int left, int right, int key) {
    int mid;
    while (left <= right) {
        mid = left + (right - left) / 2;
        if (nums[mid] == key) {
            return mid;
        } else if (nums[mid] > key) {
            right = mid - 1;
        } else {
            left = mid + 1;
        }
    }
    return -1;
}
// 方法一
// 如果重复的数字占据数组的比例较小，用二分查找，后向两侧遍历
int CountTimes(int nums[], int left, int right, int key) {
    int index = BinarySearch(nums, left, right, key);
    if (index == -1)
        return 0;
    // 从 index 向两侧遍历
    int begin = index - 1;
    int end = index + 1;
    int count = 1;
    while (begin >= left && nums[begin] == key) {
        count++;
        begin--;
    }
    while (end <= right && nums[end] == key) {
        count++;
        end++;
    }
    return count;
}
// 方法二
// 如果重复的数字占据数组的比例很大时，如果用上述方法则复杂度为O(n)
// 因此采用二分查找第一个key和最后一个key
int GetFirstKey(int nums[], int left, int right, int key);
int GetLastKey(int nums[], int left, int right, int key);

int CountTimes2(int nums[], int left, int right, int key) {
    int fistK = GetFirstKey(nums, left, right, key);
    int lastK = GetLastKey(nums, left, right, key);
    if (fistK < 0 || lastK < 0)
        return 0;
    return lastK - fistK + 1;
}
int GetFirstKey(int nums[], int left, int right, int key) {
    if (left > right)
        return -1;
    int mid = left + (right - left) / 2;
    if (nums[mid] == key) {
        // 和普通二分查找唯一不同处：只有当到达最左（右）端或者前一个节点不等于key时才结束查找
        if (mid == left || nums[mid - 1] != key)
            return mid;
        else
            return GetFirstKey(nums, left, mid - 1, key);
    } else if (nums[mid] > key) {
        return GetFirstKey(nums, left, mid - 1, key);
    } else {
        return GetFirstKey(nums, mid + 1, right, key);
    }
}
int GetLastKey(int nums[], int left, int right, int key) {
    if (left > right)
        return -1;
    int mid = left + (right - left) / 2;
    if (nums[mid] == key) {
        if (mid == right || nums[mid + 1] != key)
            return mid;
        else
            return GetLastKey(nums, mid + 1, right, key);
    } else if (nums[mid] > key) {
        return GetLastKey(nums, left, mid - 1, key);
    } else {
        return GetLastKey(nums, mid + 1, right, key);
    }
}


int main() {
    int nums[] = { 1,2,7,6,3,4,2,3,3,3,3,8,5,5,11,2,345,3,3 };
    int size = sizeof(nums) / sizeof(nums[0]);
    sort(nums, nums + size);
    PrintArray(nums);
    int key = 3;
    cout << BinarySearch(nums, 0, size - 1, key) << endl;
    cout << BinarySearch2(nums, 0, size - 1, key) << endl;
    cout << key << " 出现的次数：" << CountTimes(nums, 0, size - 1, key) << endl;
    cout << key << " 出现的次数：" << CountTimes2(nums, 0, size - 1, key) << endl;
}

运行结果

1 2 2 2 3 3 3 3 3 3 3 4 5 5 6 7 8 11 345 
9
9
3 出现的次数：7
3 出现的次数：7
[Finished in 0.6s]