704. 二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
二分查找最重要的是边界问题：
如果left<=right说明是[left,right]，当nums[mid]>target说明在左边边找，因为是闭区间所以mid位置肯定不是要找的所以right=mid-1。
如果是left<right说明是[left,right),当nums[mid]>target说明在左边边找，因为right不是闭区间所以mid位置可以写，所以right=mid
var search = function(nums, target) {
let left = 0;
let right = nums.length - 1;
if (left > right) {
return -1
}
while(left <= right){
let mid = (right + left)>>1;
if(nums[mid] === target){
return mid
}else if(nums[mid] > target){
right = mid - 1
}else{
left = mid + 1
}
}
return -1;
};
let mid = left + Math.floor((right - left) / 2);
let mid = (right + left)>>1;
35. 搜索插入位置 不停往左边区间找
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
输入: nums = [1,3,5,6], target = 5
输出: 2
在一个有序数组中找第一个大于等于 target 的下标
var searchInsert = function(nums, target) {
const n = nums.length;
let left = 0;
let right = n - 1;
let res = n;//取n就是为了处理target是最大的
while(left <= right){
let mid = (right + left) >> 1
if (target <= nums[mid]) {
res = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
return res;
};
69. x 的平方根 不停往右边区间找
给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
var mySqrt = function(x) {
let left = 0;
let right = x;
let res = -1;
while(left <= right){
let mid = left + Math.floor((right - left)/2)
if(mid * mid <= x){
res = mid
left = mid + 1;
}else if(mid * mid > x){
right = mid - 1;
}
}
return res
};
300. 最长递增子序列
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
输入： nums = [10,9,2,5,3,7,101,18]
输出： 4
解释： 最长递增子序列是 [2,3,7,101]，因此长度为 4 。
方法一：动态规划
错误：
dp[i]表示数组前i个的最长长度。dp[i]不仅仅只和前面的i-1有关而是和0～i-1位置的dp有关。
[10,9,2,5,3],我想的是[10,9,2,5]最大长度是2，来了一个3后只要3>2就dp[5] = dp[4] + 1，这明显是错误的。
正确：
dp[i]表示选择nums[i]，并且以nums[i]结尾的最长上升子序列的长度。dp[i]是和0～i-1位置的元素有关。我们还要用一个res随时记录最大的长度。
var lengthOfLIS = function(nums) {
let n = nums.length;
let dp = new Array(n).fill(1);
let res = 1;
for(let i = 1; i < n; i++){
for(let j = 0; j < i; j++){
if(nums[i] > nums[j]) {//当nums[i] > nums[j]，则构成一个上升对
dp[i] = Math.max(dp[i], dp[j]+1);//更新dp[i]
}
}
res = Math.max(res,dp[i])
}
return res
};
方法二：二分查找+贪心算法
生成一个数组res，遍历原数组然后在res数组用二分查找找出适合插入的位置，比如说res=[2，5],我们要插入3的时候，就将res[1]=3
// 例子： [9,10,2,5,3,7,101,18]
[ 9 ]
[ 9 ]
[ 9, 10 ]
[ 2, 10 ]
[ 2, 5 ]
[ 2, 3 ]
[ 2, 3, 7 ]
[ 2, 3, 7, 101 ]
查找位置永远是target<=nums[mid],但是你返回的位置取决于你是要
var lengthOfLIS = function (nums) {
let n = nums.length;
if (n <= 1) {
return n;
}
let tail = [nums[0]];//存放最长上升子序列数组
for (let i = 0; i < n; i++) {
console.log(tail)
if (nums[i] > tail[tail.length - 1]) {//当nums中的元素比tail中的最后一个大时 可以放心push进tail
tail.push(nums[i]);
} else {//否则进行二分查找
let left = 0;
let right = tail.length - 1;
while (left <= right) {
let mid = (left + right) >> 1;
if (tail[mid] < nums[i]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
tail[left] = nums[i];//将nums[i]放置到合适的位置，此时前面的元素都比nums[i]小
}
}
return tail.length;
};
4. 寻找两个正序数组的中位数
给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
输入：nums1 = [1,2], nums2 = [3,4]
输出：2.50000
解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5
var findMedianSortedArrays = function(nums1, nums2) {
let n1 = nums1.length;
let n2 = nums2.length;
if(n1 > n2){
return findMedianSortedArrays(nums2,nums1);
}
let lenAll = n1 + n2;
let left = 0;
let right = n1;
while (left<=right){
let mid1 = (left + right)>>1;
let mid2 = ((lenAll + 1) >> 1) - mid1;
let L1 = mid1 === 0 ? -Infinity : nums1[mid1 - 1];
let L2 = mid2 === 0 ? -Infinity : nums2[mid2 - 1];
let R1 = mid1 === n1 ? Infinity : nums1[mid1];
let R2 = mid2 === n2 ? Infinity : nums2[mid2];
if(L1 > R2){
right = mid1 - 1;
}else if(L2 > R1){
left = mid1 + 1
}else{
return lenAll % 2 === 0 ?
(Math.max(L1, L2) + Math.min(R1, R2)) / 2 : //长度为偶数返回作左侧较大者和右边较小者和的一半
Math.max(L1, L2) //长度为奇数返回作左侧较大者
}
}
};
162. 寻找峰值
峰值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
你必须实现时间复杂度为 O(log n) 的算法来解决此问题。
输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5
解释：你的函数可以返回索引 1，其峰值元素为 2；
或者返回索引 5， 其峰值元素为 6。
const findPeakElement = nums => {
let [left, right] = [0, nums.length - 1];
while (left < right) {
const mid = left + ((right - left) >> 1);//不断二分 寻找上升元素对
if (nums[mid] > nums[mid + 1]) {
right = mid ;//下降
} else {
left = mid + 1;//上升
}
}
return right; //right或者left
};
74. 搜索二维矩阵
编写一个高效的算法来判断 m x n 矩阵中，是否存在一个目标值。该矩阵具有如下特性：
每行中的整数从左到右按升序排列。
每行的第一个整数大于前一行的最后一个整数。
输入： matrix = [[1,3,5,7],[10,11,16,20],[23,30,34,60]], target = 3
输出： true
注意这道题目除以的是m不是n
var searchMatrix = function(matrix, target) {
let n = matrix.length;
let m = matrix[0].length;
let len = n * m;
let left = 0;
let right = len-1;
while(left <= right){
let mid = Math.floor((right - left) / 2) + left;
let row = Math.floor(mid / m);
let col = mid % m;
if(matrix[row][col] < target){
left = mid + 1;
}else if(matrix[row][col] > target){
right = mid - 1;
}else{
return true;
}
}
return false
};
34. 在排序数组中查找元素的第一个和最后一个位置
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
输入： nums = [5,7,7,8,8,10], target = 8
输出： [3,4]
这道题目很简单，就是先找目标元素，找到目标元素后往左往右不停找有没有相同的元素，找不到了就停止。
var searchRange = function(nums, target) {
let left = 0, right = nums.length - 1, mid;
while(left <= right){
mid = (left + right) >>1
if(nums[mid] === target){
break;
}else if(nums[mid] > target){
right = mid - 1;
}else{
left = mid + 1;
}
}
if(left > right) return [-1, -1];
let i = mid, j = mid;
while(nums[i] === nums[i - 1]) i--; //这里容易出错
while(nums[j] === nums[j + 1]) j++;
return [i, j];
};
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 ，它原来是一个升序排列的数组，并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
输入： nums = [4,5,6,7,0,1,2]
输出： 0
解释： 原数组为 [0,1,2,4,5,6,7] ，旋转 4 次得到输入数组。
就是找最小值最大值
low和high指针不断向中间移动，不断二分，当前节点比high节点的值小，让high等于pivot，当前节点比大于等于high节点的时候，让low等于pivot+1，最后相遇的节点就是最小值
var findMin = function(nums) {
let low = 0;
let high = nums.length - 1;
while (low < high) {
const mid = low + Math.floor((high - low) / 2);//中间节点
if (nums[mid] < nums[high]) {//当前节点比high节点的值小，让high等于mid
high = mid;
} else {
low = mid + 1;//当前节点比大于等于high节点的时候，让low等于mid+1
}
}
return nums[low];//最后相遇的节点就是最小值
};
374. 猜数字大小
猜数字游戏的规则如下：
每轮游戏，我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。
你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：
-1：我选出的数字比你猜的数字小 pick < num
1：我选出的数字比你猜的数字大 pick > num
0：我选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num
返回我选出的数字。
输入： n = 10, pick = 6
输出： 6
var guessNumber = function(n) {
let left = 1, right = n;
while (left < right) {
const mid = Math.floor(left + (right - left) / 2);
if (guess(mid) <= 0) {
right = mid; //更新查找区间为[left, mid]
} else {
left = mid + 1; //更新查找区间为[mid+1, right]
}
}
//left == right为答案
return right;
};
