二分查找的练习题目主要包括:
- 朴素二分查找
- lower_bound
- 在旋转后的排序数组总二分查找
#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;
}
};