js-剑指offer刷题记录(数组)
1.二维数组中的查找
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
我的解法
function Find(target, array){
//从第一行开始，第一个数比target大的话，
//该行所有数都比target大，跳至下一行
for (let i=0;i<array.length;i++){
if (array[i][0]>target){
continue
}//第一个数比target小的话，该行可能有target
//用indexOf找
else{
if(array[i].indexOf(target)!=-1){
console.log('有这个数！')
return true
}
}
}
return false
}
其他分析
根据矩阵的特性，从矩阵的左下角看，往右递增往上递减，从左下角开始找，如果比target大则右移如果比target小则左移（注意分清行和列）
function Find(target,array){
var x = array.length; //行
var y = array[0].length; //列
var i = x-1;
var j = 0;
while(i>=0&&j<=y-1){
if (array[i][j]>target){
i--
}
else if(array[i][j]<target){
j++
}
else{
console.log('have')
return true
}
}
console.log('none');
return false
}
一点补充
js没有多维数组，可以通过数组包含数组创建多维数组
2.数组中重复的数字
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
我的解法(弱智系列)
for循环遍历整个数组，用indexOf寻找该元素，返回的下标不是该元素的下标说明有重复元素
function duplicate(numbers, duplication){
for(let i = 0; i < numbers.length; i++){
if(numbers.indexOf(numbers[i]) != i){
duplication[0] = numbers[i]
return true
}
}
return false
}
其他分析
哈希法：用另一个长为n的数组hash，hash的下标值对应numbers中的元素值，而hash的元素值对应numbers元素出现的次数。
若numbers中元素3出现了两次，那么a[3]=2，这样遍历hash数组，哪个元素大于1则下标就是numbers中重复的元素
function duplicate1(numbers, duplication)
{
var length = numbers.length
var hash = new Array(length).fill(0)//fill方法将一个固定值替换数组的元素
for(let i=0;i<length;i++){
hash[numbers[i]]+=1
}
for(let j=0;j<length;j++){
if(hash[j]>1){
duplication[0]=j
return true
}
}
return false
}
进击：上面的做法其实把hash每个元素都赋值了，然又遍历，其实没必要，只要找到hash中第一个第一个不为0的元素就可以了
function duplicate(numbers, duplication)
{
var length = numbers.length
var hash = new Array(length).fill(0)
for(let i=0;i<length;i++){
if(hash[numbers[i]]==0){
hash[numbers[i]]+=1
}else{ //hash[numbers[i]]不为0说明重复出现了
duplication[0]=numbers[i]
return true
}
}
return false
}
数归其位：对于一个数组，把每个元素放到对应值的下标的位置上，这样对于重复的数字，一个下标就有多个数字，思想就是想办法数归其位，当发现某个元素的和值相同下标出的元素相等时，说明有重复数字(wsl)
遍历数组，判断元素a[i]和下标i是否相同
1.若相同跳过()
2.若不同，判断a[i]和a[a[i]]是否相同
2.1若不同，二者交换位置，也就是说a[i]跑到了a[i]位置 上，而a[a[i]]跑到了i位置上，对于元素a[i]来说就归位了
2.2若相同，重复元素出现了
其实元素是通过下标值这个中间量进行比较
function duplicate(numbers, duplication)
{
for(let i=0;i<numbers.length;i++){
while(i!=numbers[i]){
if(numbers[i]==numbers[numbers[i]]){
duplication[0]=numbers[i]
}else{
[numbers[i],numbers[numbers[i]]]=[numbers[numbers[i]],numbers[i]]
}
}
}
return false
}
一点补充
array.indexOf(item，start)
用于查找array中是否含有item，有则返回 item 的第一次出现的位置否则返回-1
start表示查找开始位置，没有这个参数的话则从数组开头查找
array.fill(value, start, end)
用一个固定值value填充数组，start开始位置，end终止位置，不写默认数组长度
3.构建乘积数组
给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]**A[1]*…*A[i-1]A[i+1]…A[n-1]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）
我的解法(没眼看)
根据题目可知，新数组array2的元素array2[i]等于array数组去除元素array[i]后，剩下元素的乘积。
function multiply(array)
{
var length = array.length
var array2 = []
for(let i=0;i<length;i++){
var a = array.splice(i,1) //第一步去掉array[i]，返回是一个数组[array[i]]
array2[i] = array.reduce((prevalue,item)=>{
return prevalue*item
},1) //第二步reduce函数计算array剩余元素乘积
array.splice(i,0,a[0])//把去掉的array[i]塞回array，注意a是一个单个元素的数组，所以用a[0]
}
return array2
}
其他分析
其实新数组的值B[i]可看作一下数组每行的乘积，这个数组分为上下两个三角，每个三角都能连乘。先算下三角中的连乘，即先算出B[i]中的一部分，然后倒过来按上三角中的分布规律，把另一部分也乘进去。引入一个中间变量tem表示上三角连乘的结果
function multiply(array)
{
var length = array.length
var array2 = []
//下三角计算
array2[0]=1
for(let i=1;i<length;i++){
array2[i]=array2[i-1]*array[i-1]
}
//上三角计算用tem表示
let tem = 1
for(let j=length-2;j>=0;j--){
tem=tem*array[j+1]
array2[j]=array2[j]*tem
}
return array2
}
一点补充
数组方法1
array.slice(start,end)
从数组下标start处(包括start)开始选取元素，直到下标end处结束(不包括end处)，选取的元素包含在返回的新数组中，但是array不改变
字符串也可以用这个方法，返回字符串
var array = [1,2,3,4,5]
var b = array.slice(2,3)
var c = array.slice(-3,-1) //slice(-3+5,-1+5)
console.log(b) //[3]
console.log(c) //[3,4]
console.log(array) //[1,2,3,4,5]，不改变原数组
数组方法2
array.splice(index,howmany,item1,...,itemN)
对数组先删除后添加。从下标index处(包括index处)开始删除howmany个元素，然后把item1,…,itemN添加进去。返回包含被删除的元素的数组，原数组改变
array.splice(index,howmany)
没有item的话就是删除元素，返回包含被删除的元素的数组，当howmany为0时，表示没有删除元素，返回的数组为空
var array = [1,2,3,4,5]
var b = array.splice(2,3)
console.log(array) //[1,2]，原数组改变了
console.log(b) //[3,4,5]，被删元素的数组
var c = array.splice(2,0)
console.log(c) //[]，没有删元素，返回空数组
console.log(array) //[1,2]
var d = array.splice(1,1,1)
console.log(d) //[2]
console.log(array); //[1,1]
4.顺时针打印矩阵
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.
我的解法
。。。
其他分析
打印顺序为从左到右，从上到下，从右到左，从下到上。打印的范围也随着一圈打印完而缩小。我们需要知道什么时候改变打印方向而且记录最新的打印范围。
四个变量如下
left = 0
right = matrix[0].length-1,
top = 0
bottom = matrix.length-1
循环打印：从上到下，从右到左，从下到上的顺序打印
- 根据打印边界，判断一个方向上的元素是否打印完(添加到res数组中)
- 一圈打印完，要缩小边界
- 当两边界相遇(数值相等时)，打印完毕
开始我的代码这样写的
function printMatrix(matrix) //错错错
{
if(matrix == null) return null
let left = 0,
right = matrix[0].length-1,
top = 0,
bottom = matrix.length-1
let res=[]
while(left<=right&&top<=bottom){ //左右相遇且上下相遇说明没有可打印的元素了
for(let i=left;i<=right;i++){ //left > right
res.push(matrix[top][i])
}
for(let i=top+1;i<=bottom;i++){ //top > bottom
res.push(matrix[i][right])
}
for(let i=right-1;i>=left;i--){
res.push(matrix[bottom][i])
}
for(let i=bottom-1;i>top;i--){ //注意这里不能等于top，否则就会多打印矩阵右上角的元素
res.push(matrix[i][left])
}
//一圈打印完毕，缩小打印范围
left++
right--
top++
bottom--
}
return res
}
这里就出现了一个问题就是：一行/一列的矩阵，在从右往左和从上往下打印时，就会重复打印。
也就是说对于从右往左打印时保证top和bottom不重合，从上往下打印时保证left和right不重合。修改如下
function printMatrix(matrix)
{
if(matrix == null) return null
let left = 0,
right = matrix[0].length-1,
top = 0,
bottom = matrix.length-1
let res=[]
while(left<=right&&top<=bottom){
for(let i=left;i<=right;i++){
res.push(matrix[top][i])
}
for(let i=top+1;i<=bottom;i++){
res.push(matrix[i][right])
}
for(let i=right-1;i>=left&&top<bottom;i--){
res.push(matrix[bottom][i])
}
for(let i=bottom-1;i>top&&left<right;i--){ //注意这里不能等于top，否则就会多打印矩阵右上角的元素
res.push(matrix[i][left])
}
left++
right--
top++
bottom--
}
return res
}
5.数组中出现次数超过一半的数字
我的解法
这道题和第二题有点类似。我的思路是弄个哈希数组hash其中元素表示数组某个元素的出现次数，hash的下标值对应数组元素，从头到尾遍历数组，第一次出现就push0，否则+1。但是有个局限：数组元素不能为负。
把数组从小到大排序，重复出现的数字肯定是连着的，如果他的次数大于数组长度一半，那中位数肯定是他。
采用快速排序，或者偷懒用数组的sort()方法也可以。
function MoreThanHalfNum_Solution(numbers)
{
let hash = []
numbers.sort((a,b)=>{
return a - b
})
let mid = numbers[Math.floor(numbers.length/2)]
let count = 0
for(let item of numbers){
if(item == mid)
count++
}
return count>Math.floor(numbers.length/2)? mid:0
}
其他分析
如果存在这种数字的话，那么数组其他数字次数加起来也没有这个数字次数多。
在遍历数组时保存两个值：一是数组中一个数字，一是次数。遍历下一个数字时，若它与之前保存的数字相同，则次数加1，否则次数减1；若次数为0，则保存下一个数字，并将次数置为1。遍历结束后，所保存的数字即为所得。然后再判断它是否符合条件即可。
这是一种两两不同抵消的思想，最坏的情况，这个数字都被抵消了(如[1,2,1,2,1])，由于这个数字大于数组长度一半，他肯定还剩一个。
function MoreThanHalfNum_Solution(numbers)
{
let tmp = numbers[0]
let num = 1
for(let item of numbers){
if(item == tmp){
num++
}else{
num--
}
if(num == 0){
tmp = item
num = 1
}
}
//统计次数
let count = 0
for(let item of numbers){
if(item == tmp)
count++
}
return count>Math.floor(numbers.length/2)? tmp:0
}
6.最小的k个数
输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。
我的解法
暴力解题
function GetLeastNumbers_Solution(input, k)
{
if(k>input.length) return []
input.sort((a,b)=>{
return a - b
})
return input.slice(0,k)
}
其他分析
看了题解多是用快排，躲不掉。其实这里利用了快排的partition函数，并没有完全对数组排序，而是找到第k小的数所在的部分，比如在右半部分，因为左半部分是比pivot小的，而k大于pivot的index，那么只要对右半部分排序就可以了，取出部分(可能左半部分不够k个数)。
function GetLeastNumbers_Solution(input, k)
{
if (input.length == 0 || k > input.length || k < 1) return []
let index = Partition(input,0,input.length-1)
//判断k的位置，这样知道在哪边找
while(index!=k-1){
if(index>k-1){
index = Partition(input,0,index-1)
}else{
index = Partition(input,index+1,input.length-1)
}
}
let res = input.slice(0,k)
res.sort((a,b)=>{return a-b}) //排序
return res
}
//partition函数很重要
function Partition(arr,left,right){
let pivot = arr[left] //比较的基准
//一直找到比基准小的数
while(left<right){
while(pivot<=arr[right]&&left<right){
right --
}
//放在前面
[arr[left],arr[right]] = [arr[right],arr[left]]
//找到比基准大的数
while(pivot>=arr[left]&&left<right){
left ++
}
//放在后面
[arr[left],arr[right]] = [arr[right],arr[left]]
//两个循环两个交换，保证左边都是比基准小的数，右边都是大的数，left为基准的下标
return left
}
}
一点补充
快排代码
function quickSort(a,left,right){
if(left==right)return;
let index=partition(a,left,right);//选出key下标
if(left<index){
quickSort(a,left,index-1);//对key的左半部分排序
}
if(index<right){
quickSort(a,index+1,right)//对key的右半部份排序
}
return a
}
function partition(a,left,right){
let pivot=a[left];//让基准为第一个数
while(left<right){
//找到比pivot小的数
while(pivot<=a[right]&&left<right){
right--;
}
//交换给前面，这样保证前面都是比基准小的数
[a[left],a[right]]=[a[right],a[left]]
//找到比pivot大的数
while(pivot>=a[left]&&left<right){
left++;
}
//交换给后面，这样后面都是比基准大的数
[a[left],a[right]]=[a[right],a[left]];//交换
}
//left和right相遇或者left超过right，返回pivot的下标
return left
}
7.连续子数组的最大和
HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1
我的解法
反正我是被忽悠住了。
其他分析
动态规划：多用来求最值问题。
动态规划方法1
力扣上这个解析很清晰连续子数组的最大和（动态规划，清晰图解）
- 状态定义:dp[i]表示以arr[i]结尾的子数组的最大连续子数组和
- 转移方程：dp[i-1]为负，加上dp[i-1]反而会使arr[i]变小，不如取之前的arr[i]；dp[i-1]为正，就要加上dp[i-1]
dp[i - 1]>0：dp[i] = dp[i-1] + arr[i]
dp[i−1]≤0 ：dp[i] = arr[i] - 初始状态：dp[0] == arr[0]
function FindGreatestSumOfSubArray(array)
{
let res = array[0]
let dp = array[0]
for(let i=1;i<array.length;i++){
if(dp>0){
dp = dp+array[i]
}else{
dp = array[i]
}
res = Math.max(dp,res)
}
return res
}
动态规划方法2
- 状态定义：dp[i]表示以arr[i]结尾的子数组的最大连续子数组和
- 转移方程：dp[i] = max(dp[i-1]+array[i],array[i])
以(-2,-3,4,-1,-2)为例
dp[0] = -2
dp[1] = -3
dp[2] = 4
dp[3] = 3
… - 初始状态：dp[0] == arr[0]
function FindGreatestSumOfSubArray(array)
{
let res = array[0]
let dp = array[0]
for(let i=1;i<array.length;i++){
dp = Math.max(dp+array[i],array[i])
res = Math.max(dp,res)
}
return res
}
个人觉得第二种方法更好理解。
8.把数组排成最小的数
输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3，32，321}，则打印出这三个数字能排成的最小数字为321323。
我的解法
自暴自弃法，所有可能的组合都列出来，把最小的输出。这个真的不太现实，组合列出来的话就是之前abc字符串排列组合那道题，就真的很麻烦。
其他分析
定义新的排序规则，比较两个字符串s1, s2大小的时候，先将它们拼接起来，比较s1+s2,和s2+s1那个大，如果s1+s2大，那说明s2应该放前面，所以按这个规则，s2就应该排在s1前面。
function PrintMinNumber(numbers)
{
numbers.sort((s1,s2)=>{ //s1表示后一个数，s2表示前一个数
let a = `${s1}${s2}`
let b = `${s2}${s1}`
return a-b //return正值时，s1和s2的位置不变也就是说s1在s2的后面
})
let s = ''
for(let item of numbers){
s+=item
}
return s
}
9.数组中的逆序对
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组,求出这个数组中的逆序对的总数P。并将P对1000000007取模的结果输出。 即输出P%1000000007
输入描述:
题目保证输入的数组中没有的相同的数字
数据范围：
对于%50的数据,size<=10^4
对于%75的数据,size<=10^5
对于%100的数据,size<=2*10^5
我的解法
？？？？？？
其他分析
归并算法。算法原理可以参考这片文章图解归并算法，其中这张图片很好的说明了归并算法的原理
这道题就在治的过程中统计逆序对的数目。以[7,5,6,4]为例。
-
首先归并排序的分
arr分解为L= [7,5],R = [6,4];继续分解为LL = [7], LR = [5];和RL = [6], RR = [4];
自此分解完成。 -
接下来合并
i为arrLL的数组下标，j为arrLR的数组下标, index为新数组res的下标，初始值都为0- arrLL与arrLR合并
因为arrLL[i]=7 > arrLR[j]=5，所以arrLL中7及其之后的所有数字都大于arrLR中的5，也就是说7及其之后的所有元素都可以与5组成逆序对。
所以此时7及其之后的所有元素个数(leftLen - i)即我们要的逆序对数，sum += leftLen - 1
合并之后为arrL=[5,7] - 根据上述方法将arrRL和arrRR合并为arrR=[4,6]
- 将arrL和arrR合并为arr：
5 > 4，说明5及其之后的所有元素都能与4组成逆序对；所以sum += （leftLen - 1）；
5 < 6，正常排序，不做处理
7 > 6，说明7及其之后的所有元素都能与6组成逆序对；所以sum += （leftLen - 1）；
7，正常排序，不作处理
- arrLL与arrLR合并
function InversePairs(data)
{
var sum = 0
MergeSort(data,sum)
return sum%10000000007
//下面都是归并排序
function MergeSort(arr){
if(arr.length < 2){
return arr
}
let len = arr.length
let mid = Math.floor(len/2)
let left = arr.slice(0,mid)
let right = arr.slice(mid)
return Merge(MergeSort(left),MergeSort(right))
}
function Merge(left,right){
let res = []
let i = 0,j = 0
let leftLen = left.length
let rightLen = right.length
while(i<leftLen&&j<rightLen){
if(left[i]<right[j]){
res.push(left[i])
i++
}else{
res.push(right[j])
j++
sum += leftLen - i //与归并排序的唯一区别
}
}
while(i<leftLen){
res.push(left[i])
i++
}
while(j<rightLen){
res.push(right[j])
j++
}
return res
}
}
一点补充
归并排序代码
function MergeSort(arr){
if(arr.length < 2){ //递归出口
return arr
}
let len = arr.length
let mid = Math.floor(len/2)
//左右划分
let left = arr.slice(0,mid)
let right = arr.slice(mid)
return Merge(MergeSort(left),MergeSort(right))
}
function Merge(left,right){
let res = []
let i = 0,j = 0
let leftLen = left.length
let rightLen = right.length
while(i<leftLen&&j<rightLen){
if(left[i]<right[j]){
res.push(left[i])
i++
}else{
res.push(right[j])
j++
}
}
//可能右数组比较完了，左数组还有多的
while(i<leftLen){
res.push(left[i])
i++
}
while(j<rightLen){
res.push(right[j])
j++
}
return res
}
10.数组中出现一次的数字
一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。
我的解法
用indexOf和lastIndexOf，二者返回值相等说明找到了只出现一次的数字了。一个从前往后找一个从后往前找。
function FindNumsAppearOnce(array)
{
let res = []
for(let i=0;i<array.length;i++){
if(array.indexOf(array[i])==array.lastIndexOf(array[i]))
res.push(array[i])
}
return res
}
其他分析
注意数组的特点：其他数字出现两次。异或运算有个特点：两个相同数字异或=0，一个数和0异或还是它本身。
把数组元素依次异或，最后的结果肯定就是出现一次的两个数字的异或结果，其他数字是成对的，异或都等于0了。
然后要从结果分离出两个数字：这个结果的二进制中的1，表现的是A和B的不同的位。我们就取第一个1所在的位数，假设是第3位，接着把原数组分成两组，分组标准是第3位是否为1。如此，相同的数肯定在一个组，因为相同数字所有位都相同，而不同的数，肯定不在一组。然后把这两个组按照最开始的思路，依次异或，剩余的两个结果就是这两个只出现一次的数字。
function FindNumsAppearOnce(array)
{
let tmp = array[0]
//数组异或
for(let i=1;i<array.length;i++){
tmp = tmp ^ array[i]
}
if(tmp == 0) return
//原数组分离
let index = 0
while((tmp&1) == 0){
tmp = tmp >>> 1
index ++
}
let num1=0,num2=0
for(let i=0;i<array.length;i++){
let flag = isOneOfIndex(array[i],index)
if(flag){ //flag是多少都不重要，这里就是根据index上是不是1把array中元素分开
num1 = num1^array[i]
}else{
num2 = num2^array[i]
}
}
return [num2,num1]
}
//判断num的index位上是不是1
function isOneOfIndex(num,index){
num = num>>>index
return num&1 //是1返回1就是true
}
11.数字在排序数组中出现的次数
统计一个数字在排序数组中出现的次数
我的解法
如果这个数字重复的话，由于是排序数组，肯定是连在一起。找到之后，判断下一个数是否相等，不等就返回1，相等就边计数边遍历直到与这个数不相等。
function GetNumberOfK(data, k)
{
let i=0
while(data[i]!=k){
//数字k不存在的情况
if(i==data.length){
return 0
}
i++
}
//下一个不相等或者最后一位是数字k
if(data[i+1]!==k || i==data.length-1)
return 1
let count = 0
while(data[i]==k){
count++
i++
}
return count
}
其他分析
更多采用的办法是二分查找。边界处理是真的头疼，看了好久。力扣的这篇题解中，有很直观的动画，以供参考。在排序数组中查找数字
我们要通过二分法来找数组的两个边界。
- 初始化：左边界 i=0 ，右边界 j = len(data) - 1，代表闭区间 [i, j]。
- 循环二分： 和二分法一样，当i≤j时循环(即当闭区间 [i, j]为空时跳出)；
计算中点 mid = (i + j)/2 ,向下取整；- 若data[mid] < k，则数字k一定在闭区间 [m + 1, j]中，因此执行 i = m + 1；
- 若data[mid] > k，则数字k一定在闭区间 [i, m - 1]中，因此执行 j = m - 1；
- 若data[mid] = k，则右边界 right在闭区间 [m+1, j]中；左边界left在闭区间[i, m-1]中。因此分为以下两种情况：
- 若查找right ，则执行 i = m + 1（跳出时i指向右边界）
- 若查找left，则执行 j = m - 1（跳出时i指向左边界）
- 返回值： 应用两次二分，分别查找right和left ，最终返回 right - left - 1即可。
function GetNumberOfK(data, k)
{
//let[i,j] = [0,data.length-1]
let i = 0
let j = data.length-1
while(i<=j){
let mid = Math.floor((i+j)/2)
if(data[mid]<k){
i = mid+1
}else{
j = mid-1
}
}
let left = j
i = 0
j = data.length-1
while(i<=j){
let mid = Math.floor((i+j)/2)
if(data[mid]<=k){
i = mid+1
}else{
j = mid-1
}
}
let right = i
return right-left-1
}
一点补充
二分查找
二分法用于有序数据的查找。
算法描述
- 选择中间值；
- 如果选择的值是待搜索的值，算法结束并返回；
- 如果待搜索值比选中值要小，则返回步骤①并在选中值左边的子数组中寻找。
- 如果待搜索值比选中值要大，则返回步骤①并在选中值右边的子数组中寻找。
其实很类似猜数字的游戏了。
function BinarySearch(arr,k){
let low = 0
let high = arr.length-1
while(low<=high){ //注意点：结束条件
let mid = Math.floor((low+high)/2) //注意点：下取整
if(arr[mid]<k) {low = mid+1}
if(arr[mid]>k) {high = mid-1}
if(arr[mid]==k) return mid
}
return low //这里return是指找不到时，k应该插入的位置
}