[LeetCode] 74 Search a 2D Matrix（二分查找）

二分查找

1.二分查找的时间复杂度分析：

二分查找每次排除掉一半不合适的值，所以对于n个元素的情况来说:

一次二分剩下：n/2

两次：n/4

m次：n/(2^m)

最坏情况是排除到最后一个值之后得到结果，所以：
n/(2^m) = 1

2^m = n

所以时间复杂度为：log2(n)

2.二分查找的实现方法：

（1）递归

int RecursiveBinSearch(int arr[], int bottom, int top, int key) {
if (bottom <= top) {
int mid = (bottom + top) / 2;
if (arr[mid] == key) {
return mid;
}
else if (key < arr[mid]) {
return RecursiveBinSearch(arr, bottom, mid - 1, key);
}
else {
return RecursiveBinSearch(arr, mid + 1, top, key);
}
}
else {
return -1;
}
}

（2）非递归

int nonRecursiveBinSearch(int arr[], int size, int key) {
int bottom = 0, top = size - 1, mid;
while (bottom <= top) {
mid = (bottom + top) / 2;
if (arr[mid] == key) {
return mid;
}
else if (key < arr[mid]) {
top = mid - 1;
}
else {
bottom = mid + 1;
}
}
return -1;
}

3.LeetCode题目：74 Search a 2D Matrix

原题地址：
https://leetcode.com/problems/search-a-2d-matrix/description/

题目：

解法：

这道题给出一个二维数组（已排序），再给定一个数，让我们确定这个数是否在这个二维数组里面。由于这个二维数组是排好序的，因此我们可以使用两次二分查找，第一次使用先定位好这个数在第几行，第二次使用确定这个数在第几列。

代码如下：

class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
if (matrix.size() == 0 || matrix[0].size() == 0) return false;
int col = getCol(matrix, 0, matrix.size() - 1, target);
if (col == -1) {
return false;
}
else {
return isExist(matrix, col, 0, matrix[col].size() - 1, target);
}
}
int getCol(vector<vector<int>>& matrix, int first, int last, int target) {
if (first > last) return -1;
int mid = (first + last) / 2;
if (matrix[mid][0] <= target && target <= matrix[mid][matrix[mid].size() - 1]) {
return mid;
}
else {
if (target < matrix[mid][0]) {
return getCol(matrix, first, mid - 1, target);
}
else {
return getCol(matrix, mid + 1, last, target);
}
}
}
bool isExist(vector<vector<int>>& matrix, int col, int first, int last, int target) {
if (first > last) {
return false;
}
else {
int mid = (first + last) / 2;
if (matrix[col][mid] == target) {
return true;
}
else {
if (matrix[col][mid] > target) {
return isExist(matrix, col, first, mid - 1, target);
}
else {
return isExist(matrix, col, mid + 1, last, target);
}
}
}
}
};

后来出于好奇直接用两层循环来查找，最后所花的时间竟然和用二分查找一样，哎：

class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
for (int i = 0; i < matrix.size(); i++) {
for (int j = 0; j < matrix[i].size(); j++) {
if (matrix[i][j] == target) return true;
}
}
return false;
}
};