二分查找练习题

二分查找的练习题目主要包括：

1. 朴素二分查找
2. lower_bound
3. 在旋转后的排序数组总二分查找

#include<vector>
using namespace std;
class BinarySearch {
public:
    /************************************************************************/
    /* binary search
    /************************************************************************/
    int bSearch(vector<int>& data, int target) {
        int end = data.size() - 1;
        int beg = 0;
        while (beg < end) {
            int mid = (beg + end) / 2;
            if (data[mid] == target) {
                return mid;
            } else if (data[mid] > target) {
                end = mid - 1;
            } else if (data[mid] < target) {
                beg = mid + 1;
            }
        }
        return -1;
    }
    int bSearch2(vector<int>& data, int target, int beg, int end) {
        if (beg == end) return -1;
        int mid = (beg + end) / 2;
        if (data[mid] == target) return mid;
        else if(data[mid] < target) return bSearch2(data, target, mid + 1, end);
        else return bSearch2(data, target, beg, mid - 1);
    }
    /************************************************************************/
    /* lower_bound                                                          */
    /************************************************************************/
    int lbSearch(vector<int>& data, int target) {
        return lbSearch(data, target, 0, data.size());
    }
    int lbSearch2(vector<int>& data, int target) {
        return lbSearch(data, target, 0, data.size());
    }
    /************************************************************************/
    /* find element whose abs value is the smallest                         */
    /************************************************************************/
    int minAbs(vector<int>& data) {
        int pos = lbSearch(data, 0);
        if (data[pos] == 0) {
            return pos;
        } else {
            if (pos > 0 && abs(data[pos - 1]) < abs(data[pos])) {
                return pos -1;
            }
            return pos;
        }
    }
    /************************************************************************/
    /* find element in sorted array after rotation                          */
    /************************************************************************/
    int rotatedSearch(vector<int>& data, int target) {
        int beg = 0;
        int end = data.size();
        while (beg < end) {
            int mid = (beg + end) / 2;
            if (data[mid] == target) return mid;
            else {
                //7 6 5 4 1 2 3 
                if (data[mid] < data[end - 1]) {//mid+1 ~ end is ordered increasingly 
                    if (data[mid] < target && target <= data[end - 1]) {
                        beg = mid + 1;
                    } else {
                        end = mid;//return rotatedSearch(data, target, beg, mid);
                    }
                } else if (data[mid] > data[end - 1]) { // low ~ mid is ordered decreasingly
                    if (data[mid] < target && target <= data[beg]) {
                        end = mid;
                    } else {
                        beg = mid + 1;//return rotatedSearch(data, target, mid + 1, end);
                    }
                } else { //can not do any judgement because of duplication 
                    beg += 1;
                }
            }
        }
        return -1;
    }
private:
    int lbSearch2(vector<int>& data, int target, int beg, int end) {
        if (beg == end) {
            if (beg > 0 && data[beg - 1] == target) return beg - 1;
            return beg;
        } 
        int mid = (beg + end) / 2;
        if (data[mid] <= target) return lbSearch2(data, target, mid + 1, end);
        else return lbSearch2(data, target, beg, mid - 1);
    }
    int lbSearch(vector<int>& data, int target, int beg, int end) {
        while (beg < end) {
            int mid = (beg + end) / 2;
            if (data[mid] <= target) {
                beg = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        if (beg > 0 &&data[beg - 1] == target) return beg - 1;
        return beg;
    }
};