1. 二分法搜索简介及模板

例1. 在升序数组中，找第一次出现target对象的索引

2. 求开根号 sqrt(x)

例2. int sqrt( int x) 求整数的开方

例3. double sqrt (doube x) 求浮点型数值的开方

3. 二维矩阵中找target

例4. 严格递增矩阵中，查找target

例5. 非严格递增二维矩阵中找target.

4. 拓展应用题

例6. 一维排序数组中找正确的插入位置

例7. 统计比给定整数小的数的个数

例8. 一维排序数组寻找 target 出现的区间

例9. 寻找第一个错误的版本

5. 旋转数组

例10. 寻找旋转排序数组中的最小值（无重复元素）

例11. 寻找旋转排序数组中的最小值（有重复元素）

例12. 寻找旋转排序数组中的指定target（无重复元素）

例13. 寻找旋转排序数组中的指定target（有重复元素）

1. 二分法搜索简介及模板

参考：九章算法

通常什么时候会用到二分法？

当一个搜索问题可以使用for循环进行O(n)时间复杂度搜索，为了优化到O(logN)级别时，通常会用到二分搜索法。
- 出现 sorted 字眼时，即已排序的集合时。

模板如例1所示：

核心思想： 不断的缩小搜索范围！不是想着一下子找到target, 而是想着怎么样缩小范围到2个数！
- O(n) ->O(n/2)->O(n/4)->...O(1)
本质：找满足某个条件的最后一个或第一个位置
- 再深层的本质：保留有答案的一边，没有答案的一边不要。。
- 再再深层的本质：每次留下一半！不断缩小搜索范围

理解二分法的三个层次：

1. 定义头尾指针，取中点，判断往哪里走；
2. 分析问题是什么：是寻找第一个满足条件的位置，还是最后一个满足条件的位置；
3. 保留谁：保留剩余的一定有解的一半。

例1. 在升序数组中，找第一次出现target对象的索引

描述：

给定一个排序的整数数组（升序）和一个要查找的整数 target，用O(logn)O(logn)的时间查找到target第一次出现的下标（从0开始），如果target不存在于数组中，返回-1。

输入：

数组 = [1, 2, 3, 3, 4, 5, 10]
target = 3

输出：2

模板代码：

找 第一个 = target 的位置

class Solution {
public:/*** @param nums: The integer array.* @param target: Target to find.* @return: The first position of target. Position starts from 0.*/int binarySearch(vector<int> &nums, int target) {if (nums.size() == 0) { //string有size()也有length(), vector只有size()return -1;}int start = 0;int end = nums.size() - 1;while (start + 1 < end) {                 //注意: 这里是start+1, while只是为了将搜索范围减小到相邻的2个元素即可！int mid = start + (end - start) / 2;  //注意：这里不是(start+end)/2, 防止(start+end)太大，导致越界！更不是 (start - end) / 2if (nums[mid] == target) {end = mid;           //模板变化部分 (如 last positon: start = mid; 后面 if 颠倒位置； 又如：any position: 这里直接 return mid;)} else if (nums[mid] < target) {start = mid;} else {end = mid;}}if (nums[start] == target) { //模板变化部分 (如 last positon: 变化两个if前后顺序)return start;} if (nums[end] == target) {return end;}return -1;}
};

拓展：

last position: lintcode 458 · 目标最后位置（最后一个 = target 的位置）
any position: leecode

Tips: 递归recursion与while-loop

工程开发中：我们尽量避免recursion, 因为很占栈空间！！！而系统一般给程序分配很少的栈空间，比如8M大小。对于搜索问题，一般可以用recursion, 对于二叉树的前中序遍历，递归太简单，一般面试官会考recursion.

2. 求开根号 sqrt(x)

例2. int sqrt( int x) 求整数的开方

int mySqrt(int x) { }

给你一个非负整数 x ，计算并返回 x 的算术平方根。由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

等价于求最大的一个整数num，使num^2 <= x. (last position问题：最后一个 <= target)

class Solution {
public:int mySqrt(int x) {if (x <= 0)return 0;int start = 0;int end = x;while (start + 1 < end) {int mid = start + (end -start) / 2;long long num = (long long) mid * mid; //注意：这里要做强制转化！！！！if (num == x) {start = mid; //return mid; //这两句均可} else if (num < x) {start = mid;} else {end = mid;}}if ((long long)end * end <= x) {        //注意：这里要有等于号！这里要做强制转化！！！！return end;}if ((long long)start * start <= x) {    //注意：这里要有等于号！这里要做强制转化！！！！return start;}return 0;}
};

例3. double sqrt (doube x) 求浮点型数值的开方

对应 lintcode 586 · 对x开根II

描述：

实现 double sqrt(double x) 并且 x >= 0。计算并返回x开根后的值。精确度保持在小数点后12位。

例1:

输入: n = 2
输出: 1.41421356

例2:

输入: n = 3
输出: 1.73205081

代码：

区别：这里的逻辑不再是找两个相邻的，而是找两个相等的数 （注意double怎么判断相等）！

class Solution {
public:/*** @param x: a double* @return: the square root of x*/double PRECISION = 1e-10;double sqrt(double x) {double start = 0;double end   = x;if (x < 1) { //注意：这里 < 1的数值x，上节应该是1end = 1;}while (end - start > PRECISION) {   //特别注意: 这里不是+1了，也不是 start<end (会超时！)double mid = start + (end - start) / 2 ;double num = mid * mid;if (num < x) {                 //注意：这里的逻辑不再是找两个相邻的，而是找两个相等的数！//这里不要使用 abs(num-x)<1e-10,计算结果不是"最大"的result^2 < xstart = mid; } else {end = mid;}}return start; // 等价于 return end;}
};

3. 二维矩阵中找target

例4. 严格递增矩阵中，查找target

描述

写出一个高效的算法来搜索 m × n矩阵中的值 target 。

这个矩阵具有以下特性：

每行中的整数从左到右是排序的。
每行的第一个数大于上一行的最后一个整数。

样例 1：

输入：

矩阵 = [[5]]
target = 2

输出：

false

解释：矩阵中没有包含2，返回false。

样例 2：

输入：

LintCode 领扣

输出：

true

解释：矩阵中包含3，返回true。

代码：

思想：严格递增的二维数组，其实可以当做是一维数组看待，只不过，遍历时，一维数组的array [index], 对应的matrix中的matrix [index/col] [index%col], 其他等同于从一维数组中找target （找是否存在 = target ）.

class Solution {
public:/*** @param matrix: matrix, a list of lists of integers* @param target: An integer* @return: a boolean, indicate whether matrix contains target*/bool searchMatrix(vector<vector<int>> &matrix, int target) {// write your code hereif (matrix.empty()) {return false;}int start = 0;int row = matrix.size();int col = matrix[0].size();int end = row * col - 1; //注意： 这里作为索引，要减 1while (start + 1 < end) {int mid = start + (end - start) / 2;if (matrix[mid/col][mid%col] == target) { //注意：取矩阵元素的方式！return true;} else if (matrix[mid/col][mid%col] < target) {start = mid;} else {end = mid;}}if (matrix[start/col][start%col] == target) {return true;}if (matrix[end/col][end%col] == target) {return true;}return false;}
};

例5. 非严格递增二维矩阵中找target.

搜索二维矩阵，通过出现target的个数（类似剑指offer.04题 = leecode 240. 搜索二维矩阵 II : 判断是否出现即可），这里虽然未直接出现“二分”，但本质是一样的，不断缩减搜索的规模。

描述：

写出一个高效的算法来搜索m×n矩阵中的值，返回这个值出现的次数。这个矩阵具有以下特性：每行中的整数从左到右是排序的。每一列的整数从上到下是排序的。在每一行或每一列中没有重复的整数。

样例 1：

输入：

矩阵 = [[3,4]]
target = 3

输出：1

解释：矩阵中只有1个3。

样例 2：

输入：

矩阵 = [[1, 3, 5, 7],[2, 4, 7, 8],[3, 5, 9, 10]]
target = 3

输出：2

解释：矩阵中有2个3。

挑战：要求O(m+n) 时间复杂度和O(1) 额外空间

代码：

从 左上 -》右下搜索 或者从左下-》右上搜索。

class Solution {
public:/*** @param matrix: A list of lists of integers* @param target: An integer you want to search in matrix* @return: An integer indicate the total occurrence of target in the given matrix*/int searchMatrix(vector<vector<int>> &matrix, int target) {// // 从左下到右上-ok// if (matrix.empty()) {//     return 0;// }// int rows = matrix.size();// int cols = matrix[0].size();// int row  = rows -1;// int col = 0;// int count = 0;// while (col < cols && row >= 0) {//     if (matrix[row][col] == target) {//         ++count;//         ++col; //注意：这里相等时，仍然要继续向右搜索，不然就死循环了//     } else if (matrix[row][col] < target) {//         ++col;//     } else {//         --row;//     }// }// return count;// 从右上到左下-okif (matrix.empty()) {return 0;}int rows = matrix.size();int cols = matrix[0].size();int row  = 0;int col = cols - 1;int count = 0;while (row < rows && col >= 0) {if (matrix[row][col] == target) {++count;--col; //注意：这里相等时，仍然要继续向左搜索，不然就死循环了} else if (matrix[row][col] < target) {++row;} else {--col;}}return count;}
};

4. 拓展应用题

例6. 一维排序数组中找正确的插入位置

lintcode 60 · 搜索插入位置 = leecode 35. 搜索插入位置（简单）

描述

给定一个排序数组和一个目标值，如果在数组中找到目标值则返回索引。如果没有，返回到它将会被按顺序插入的位置。你可以假设在数组中无重复元素。

样例

样例 1：

输入：

数组 = [1,3,5,6]
target = 5

输出：2

解释：5在数组中索引为2。

样例 2：

输入：

数组 = [1,3,5,6]
target = 2

输出：1

解释：2应该被插到索引为1的位置。

样例 3：

输入：

数组 = [1,3,5,6]
target = 7

输出：4

解释：7应该被插到索引为4的位置。

样例 4：

输入：

数组 = [1,3,5,6]
target = 0

输出：0

解释：0应该被插到索引为0的位置。

挑战: 时间复杂度为O(log(n))

代码

解法：等价于找到 第一个 >= target 的值的位置（一般不说明默认都是升序数组）

class Solution {
public:/*** @param A: an integer sorted array* @param target: an integer to be inserted* @return: An integer*/int searchInsert(vector<int> &A, int target) {// write your code hereif (A.empty()) {return 0; // 注意：数组为空时，返回第一个位置，即0}int start = 0;int end = A.size() - 1;while (start + 1 < end) {int mid = start + (end - start) / 2;if (A[mid] == target) {return mid;  //题中已经假设数组无重复元素} else if (A[mid] < target) {start = mid;} else {end = mid;}}if (A[start] >= target) { //特别注意：这里的返回条件，上述操作只是将规模缩小到2个数，这两个数与target的大小关系是不一定的return start;       //比如[1,2,3] target=0或者1}if (A[end] >= target) {return end;         //比如[1,2,3] target=3}return A.size();        //比如[1,2,3] target=4}
};

例7. 统计比给定整数小的数的个数

lintcode 248 https://www.lintcode.com/problem/248/

描述

给定一个整数数组（下标由 0 到 n-1，其中 n 表示数组的规模，数值范围由 0 到 10000）(可能有重复元素)，以及一个查询列表。对于每一个查询，将会给你一个整数，请你返回该数组中小于给定整数的元素的数量。在做此题前，最好先完成线段树的构造 and 线段树查询 II 这两道题目。

样例 1:

输入: array =[1,2,7,8,5] queries =[1,8,5]
输出:[0,4,2]

样例 2:

输入: array =[3,4,5,8] queries =[2,4]
输出:[0,1]

样例 3:

输入: array =[1,1,1,1,1,1] queries =[1,2,3,4]
输出:[0,6,6,6]

代码

该题基本上等价于 “例6. 一维排序数组中找正确的插入位置”，也是寻找 第一个 >= target 的位置，区别在于搜索的数组是无序的，另外可能有重复元素。

class Solution {
public:/*** @param A: An integer array* @param queries: The query list* @return: The number of element in the array that are smaller that the given integer*/vector<int> countOfSmallerNumber(vector<int> &A, vector<int> &queries) {// write your code heresort (A.begin(), A.end());vector<int> result;for (int i = 0; i < queries.size(); ++i) {result.push_back(smallerThanTarget(A, queries[i]));}return result;}//排序数组中找第一个>=target的元素位置int smallerThanTarget(vector<int> & A, const int target) {if (A.empty()) {return 0;}int start = 0;int end = A.size() - 1;while (start + 1 < end) {int mid = start + (end - start) / 2;if (A[mid] == target) {end = mid; //注意：考虑可能有重复元素} else if (A[mid] < target) {start = mid;} else {end = mid;}}if (A[start] >= target) { //注意: 找第一个>=target的元素位置return start;}if (A[end] >= target) {return end;}return A.size(); // 等价于 ruturn end + 1; //特别注意： 如[1,2,2,3] target = 4}
};

例8. 一维排序数组寻找 target 出现的区间

61 · 搜索区间 lintcode

描述

给定一个包含 n 个整数的排序数组，找出给定目标值 target 的起始和结束位置。

如果目标值不在数组中，则返回[-1, -1]

样例 1：

输入：

数组 = []
target = 9

输出：

[-1,-1]

解释：9不在数组中。

样例 2：

输入：

数组 = [5, 7, 7, 8, 8, 10]
target = 8

输出：

[3,4]

解释：数组的[3,4]子区间值为8。

挑战: 时间复杂度 O(log n)

代码

这时 first position = target 和 last position = target 的综合罢了, 其他没什么区别，（也有人尝试将两种方法加flag合并, 个人认为这样只是减少了代码量，逻辑上就不那么清晰了）。

时间复杂度 2O(logN) = O(logN)

class Solution {
public:/*** @param A: an integer sorted array* @param target: an integer to be inserted* @return: a list of length 2, [index1, index2]*/vector<int> searchRange(vector<int> &A, int target) {// write your code herevector<int> internal(2);internal[0] = findFirstPosition(A, target);internal[1] = findLastPosition(A, target);return internal;}int findFirstPosition(vector<int> & A, int target) {if (A.empty()) {return -1;}int start = 0;int end = A.size() - 1;while (start + 1 < end) {int mid = start + (end - start) / 2;if (A[mid] == target) {end = mid; //first position} else if (A[mid] < target) {start = mid;} else {end = mid;}}if (A[start] == target) { //first positionreturn start;}if (A[end] == target) {return end;}return -1;}int findLastPosition(vector<int> & A, int target) {if (A.empty()) {return -1;}int start = 0;int end = A.size() - 1;while (start + 1 < end) {int mid = start + (end - start) / 2;if (A[mid] == target) {start = mid; //last position} else if (A[mid] < target) {start = mid;} else {end = mid;}}if (A[end] == target) { //last positionreturn end;}if (A[start] == target) {return start;}return -1;}
};

例9. 寻找第一个错误的版本

leecode 278. 第一个错误的版本 = lintcode 74 · 第一个错误的代码版本

描述

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。

假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。

你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。

示例 1：

输入：n = 5, bad = 4 输出：4

解释：
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。

示例 2：

输入：n = 1, bad = 1 输出：1

提示：1 <= bad <= n <= 231 - 1

代码

无它，等价于例1, 找 first position = target 问题，只不过这里的 target，是通过题目中的isBadVersion获得的bool变量（true）

// The API isBadVersion is defined for you.
// bool isBadVersion(int version);class Solution {
public:int firstBadVersion(int n) {int start = 1;int end = n;while (start + 1 < end) {int mid = start + (end - start) / 2;if (isBadVersion(mid) == true) {end = mid;} else {start = mid;}}if (isBadVersion(start) == true) {return start;}if (isBadVersion(end) == true) {return end;}return  n; // 等价于return end;}
};

5. 旋转数组

例10. 寻找旋转排序数组中的最小值（无重复元素）

对应lintode 159 · 寻找旋转排序数组中的最小值 = leecode 153. 寻找旋转排序数组中的最小值

描述：已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到：若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]；若旋转 7 次，则可以得到 [0,1,2,4,5,6,7]；注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。给你一个元素值 互不相同 的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的最小元素。

示例 1：

输入：nums = [3,4,5,1,2] 输出：1
解释：原数组为 [1,2,3,4,5] ，旋转 3 次得到输入数组。

示例 2：

输入：nums = [4,5,6,7,0,1,2] 输出：0
解释：原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。

代码

等同于寻找 first position < target 的位置，这里的 target是 数组中的最后一个元素.

class Solution {
public:int findMin(vector<int>& nums) {int start = 0;int end = nums.size() - 1;int target = nums[end];  //注意：这里将最后一个元素当成是target.找 first position < targetwhile (start + 1 < end) {int mid = start + (end - start) / 2;if (nums[mid] < target) { //无重复元素的数组 如 [4,0,1,2,3]end = mid;} else {start = mid;}}return min(nums[start], nums[end]);// if (nums[start] < target) { //ok,等价于上述min(a,b) 返回 fisrt position < target//     return nums[start];// } else {//     return nums[end];// }}
};

例11. 寻找旋转排序数组中的最小值（有重复元素）

154. 寻找旋转排序数组中的最小值 II = 剑指 Offer 11. 旋转数组的最小数字 = lintcode 160 · 寻找旋转排序数组中的最小值 II （级别：困难）

描述

已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次旋转后，得到输入数组。例如，原数组 nums = [0,1,4,4,5,6,7] 在变化后可能得到：
若旋转 4 次，则可以得到 [4,5,6,7,0,1,4]
若旋转 7 次，则可以得到 [0,1,4,4,5,6,7]
注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]] 。

给你一个可能存在重复元素值的数组 nums ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的最小元素。

示例 1：

输入：nums = [1,3,5] 输出：1

示例 2：

输入：nums = [2,2,2,0,1] 输出：0

代码

其中一种方式：可以仍然以最后一个元素作为 target, first position < target 的元素即可。

特别注意：这里有重复元素，所以，这里多判断两种情况 1）无旋转时：if (nums[start]<target) 和 2）几乎全部是重复元素时： if (nums[mid]==target)

若是搜索范围内的数字没有旋转，且 nums[mid] == target，则最小值可能是第一个值比如数组[1,3,3], 所以要加第一个直接return，而且必须加在while内（比如数组[10,1,10,10,10]）。当 nums[mid] == target时（中间值等于目标值时），最小值可能在后半段（如 [1,1,1,3,0,1]时），也可能在前半段（如 [1,3,0,1,1,1,1]），所以只能走一小步，即 start +=1。
- 记住一个特别的case: 如 [10,1,10,10,10]， [10,10,10,1,10]， [1,1,1,1,1,0,1,1]， [1,1,0,1,1,1,1,1] 这些情况下算法退化为最坏情况，即时间复杂度降为O(n).

class Solution {
public:int findMin(vector<int>& nums) {int start = 0;int end = nums.size() - 1;int target = nums[end];  //注意：这里将最后一个元素当成是target.while (start + 1 < end) {if (nums[start] < target) {         //方式2: target 换成 nums[end]return nums[start]; //特别注意：在while循环中判读！比如 数组[1,3,3] [10,1,10,10,10]}int mid = start + (end - start) / 2;if (nums[mid] == target) {          //方式2: target 换成 nums[end]++start;    //特别注意：相等时要谨慎！只后移一位即可，并且此时 nums[start]不应小于nums[start+1], 即上面的特别注意不能少}else if (nums[mid] < target) {      //方式2: target 换成 nums[end]end = mid;} else {start = mid;}}return min(nums[start], nums[end]);}
};

例12. 寻找旋转排序数组中的指定target（无重复元素）

lintcode 62 · 搜索旋转排序数组 = leetcode 33. 搜索旋转排序数组

描述：整数数组 nums 按升序排列，数组中的值 互不相同 。在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
示例 1：
输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4
示例 2：
输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

代码

与旋转数组中找最小值类似。因为我们不确定target在旋转数组的前半部分还是后半部分，所以使用二分法将数组分成2半，对升序排列的一半（判断是否是升序： if (nums[start] < nums[mid]) ）进行二分查找，即移动 start 或者 end的位置。在若前半段是升序，则在 [start, mid）中查找 target, 若后半段是升序，则在 (mid, end] 中查找。注意区间的开闭。

class Solution {
public:int search(vector<int>& nums, int target) {int n = nums.size();if (n == 0) {return -1;}int start = 0;int end = n - 1;while (start + 1 < end) {int mid = start + (end - start) / 2;  //一个好例子：如 5,6,1,2,3,4if (nums[start] < nums[mid]) { //此时说明搜索范围 [start, end) 是升序子数组，按照二分法进行搜索即可if (nums[start] <= target && nums[mid] > target) {end = mid;} else {start = mid;}} else {//搜索范围[start, end)不是升序数组，则搜索另一个升序子数组(mid, end], 则再次使用二分法进行划分if (nums[mid] < target && nums[end] >= target) {start = mid;} else {end = mid;}}}if (nums[start] == target) {return start;}if (nums[end] == target) {return end;}return -1;        }
};

例13. 寻找旋转排序数组中的指定target（有重复元素）

lintcode 63 · 搜索旋转排序数组 II = leecode 面试题 10.03. 搜索旋转数组

算法笔记_面试题_17.二分法搜索_模板及示例十几道相关推荐

算法笔记_183:历届试题九宫重排(Java)
目录 1 问题描述 2 解决方案 1 问题描述问题描述如下面第一个图的九宫格中,放着 1~8 的数字卡片,还有一个格子空着.与空格子相邻的格子中的卡片可以移动到空格中.经过若干次移动,可以形成 ...
算法笔记_172:历届试题波动数列(Java)
目录 1 问题描述 2 解决方案 1 问题描述问题描述观察这个数列: 1 3 0 2 -1 1 -2 ... 这个数列中后一项总是比前一项增加2或者减少3. 栋栋对这种数列很好奇,他想知道长度 ...
算法笔记学习（3）---深度优先搜索（DFS）
深度优先搜索(DFS) 设想我们现在身处一个巨大的迷宫之中,以当前所在位置为起点,沿着一条路向前走,当碰到岔路口的时候,就选择其中一个岔道口前进.如果选择的这个岔路前方是一条死路,就退回到这个岔道口, ...
算法笔记_188:历届试题危险系数(Java)
目录 1 问题描述 2 解决方案 1 问题描述问题描述抗日战争时期,冀中平原的地道战曾发挥重要作用. 地道的多个站点间有通道连接,形成了庞大的网络.但也有隐患,当敌人发现了某个站点后,其它站点 ...
【数据结构和算法笔记】：图的深度优先搜索（DFS）
算法笔记.胡凡第6章 C++标准模板库(STL）介绍
6.1 vector常见用法详解 6.1.1.vector定义 vector<int> name; 6.1.2.vector容器元素访问 (1) 下标:v[0] (2)迭代器 vector ...
el-select 多选取值_数值优化|笔记整理（3）——线搜索中的步长选取方法，线性共轭梯度法...
上一节笔记传送门: 学弱猹:数值优化|笔记整理(2)--线搜索:步长选取条件的收敛性zhuanlan.zhihu.com ------------------------------------ 大 ...
javascript进制转换_《算法笔记》3.5小节——入门模拟-gt;进制转换
@[TOC] # Contest100000579 - <算法笔记>3.5小节--入门模拟->进制转换 ## 例题 ### PATB1022 PTA | 程序设计类实验辅助教学平台 ...
回溯法采用的搜索策略_数值优化|笔记整理（3）——线搜索中的步长选取方法，线性共轭梯度法...
上一节笔记传送门: 学弱猹:数值优化|笔记整理(2)--线搜索:步长选取条件的收敛性zhuanlan.zhihu.com ------------------------------------ 大 ...
淘宝电商搜索EBR算法笔记
淘宝电商搜索EBR算法笔记 - 知乎<Embedding-based Product Retrieval in Taobao Search>介绍了淘宝目前最新的EBR算法.仍然是一个双塔的 ...

算法笔记_面试题_17.二分法搜索_模板及示例十几道

1. 二分法搜索简介及模板

例1. 在升序数组中，找第一次出现target对象的索引

2. 求开根号 sqrt(x)

例2. int sqrt( int x) 求整数的开方

例3. double sqrt (doube x) 求浮点型数值的开方

3. 二维矩阵中找target

例4. 严格递增矩阵中，查找target

例5. 非严格递增二维矩阵中找target.

4. 拓展应用题

例6. 一维排序数组中找正确的插入位置

例7. 统计比给定整数小的数的个数

例8. 一维排序数组寻找 target 出现的区间

例9. 寻找第一个错误的版本

5. 旋转数组

例10. 寻找旋转排序数组中的最小值（无重复元素）

例11. 寻找旋转排序数组中的最小值（有重复元素）

例12. 寻找旋转排序数组中的指定target（无重复元素）

例13. 寻找旋转排序数组中的指定target（有重复元素）

算法笔记_面试题_17.二分法搜索_模板及示例十几道相关推荐

最新文章

热门文章