8/9 二分查找

主要逻辑不复杂·，主要是边界问题
二分查找

踩坑：做除法运算要用Number.flow或者parseInt

var search = function(nums, target) {
    let left = 0,right = nums.length-1
    while(left<=right) {
        let mid =parseInt(left + (right-left)/2) 
        if(nums[mid]===target) {
            return mid
        }
        else if(nums[mid]>target) {
            right = mid -1
        }
        else left = mid +1
    }
    return -1
};

在排序数组中查找数字 I

思路有两种：找到左右上下界，判断长度；或者随便找到一个值，往两边扩展

var search = function(nums, target) {
    let l = 0, r = nums.length
    let flag = -1
    while(l<r) {
        let mid = parseInt(l+(r-l)/2)
        if(nums[mid] === target) {
            flag = mid 
            break
        }
        else if(nums[mid] >target) {
            r = mid
        }
        else l = mid + 1
    }
    if(flag === -1) {
        return 0
    }
    let count = 0,left = flag-1,right = flag
    while(left>=0 && nums[left]===target) {
        left--
        count ++
    }
    while(right<nums.length && nums[right]===target) {
        right++
        count++
    }
    return count
};

在排序数组中查找元素的第一个和最后一个位置

优化思路：还是全部用左右闭合写法吧，不容易错，然后两个函数可以合并成一个，或者这道题直接找到一个，往左右在搜索边界即可

var searchRange = function(nums, target) {
    const findRight = ()=> {
        let left = 0,right = nums.length
        while(left <right) {
            let mid = parseInt(left+(right-left)/2)
            if(nums[mid] === target) {
                left = mid + 1
            }
            else if(nums[mid] > target) {
                right = mid
            }
            else left = mid + 1
        }
        if(right-1<nums.length&&nums[right-1]===target) {
            return right-1
        }
        else return -1
    }
        const findLeft = ()=> {
            let left = 0,right = nums.length
        while(left <right) {
            let mid = parseInt(left+(right-left)/2)
            if(nums[mid] === target) {
                right = mid
            }
            else if(nums[mid] > target) {
                right = mid
            }
            else left = mid + 1
        }
        if(left>=0&&nums[left]===target) {
            return left
        }
        else return -1
    }
    return [findLeft(),findRight()]
};

在 D 天内送达包裹的能力

ar shipWithinDays = function(weights, days) {
    //二分答案，答案必定是1-sum,对于每一个分支的判断条件是，超过days就失效
    let left = 0 //这里可以用Math.max(...weights)
    let sum = weights.reduce((acc,cur)=>{
        left = left >cur?left:cur
        return acc+cur
    },0)
    let right = sum
    let result = sum
    const judge = (mid)=> {
        let count = 0,day =1,flag = 0
        for(let i = 0;i<weights.length;i++) {
            count+=weights[i]
            if(count>mid) {
                day++
                count = weights[i]
            }
            if(day>days) {
            return false
            }
        }
        return true
        //forEach没办法及时中止返回，耗时大
        // weights.forEach((item)=>{
        //     if(item>mid) {
        //         flag = -1
        //         return
        //     }
        //     count+=item
        //     if(count>mid)  {
        //         day++
        //         count = item
        //     }
        //     if(day>days)
        //     flag = -1
        // })
        return flag === 0 ?true:false
    }
    while(left<=right) {
        let mid = parseInt(left+(right-left)/2)
        if(judge(mid)) {
            result = mid
            right = mid -1
        }
        else {
            left = mid + 1 
        }
    }
    return result
};

分割数组的最大值
和上面一题一毛一样

var splitArray = function(nums, k) {
    let left = Math.max(...nums) 
    let right = nums.reduce((acc,cur)=>acc+cur)
    let result = right
    const judge = (mid)=> {
        let count = 0,mm = 1
        for(let idx = 0;idx<nums.length;idx++) {
            count += nums[idx]
            if(count>mid) {
                mm++
                count = nums[idx]
            }
            if(mm>k) {
                return false
            }
        }
        return true
    }
    while(left<=right) {
        let mid = parseInt(left + (right -left)/2)
        if(judge(mid)) {
            result = mid
            right = mid -1
        }
        else {
            left = mid + 1
        }
    }
    return result
};

爱吃香蕉的珂珂

坑，取余的时候的判断需要加括号，另外不要操作原数组

var minEatingSpeed = function(piles, h) {
    let min = 1
    let max = Math.max(...piles)
    let result = max
    const judge = (mid)=> {
        let count = 0,max=0
        for(let idx = 0;idx<piles.length;idx++) {
            max = piles[idx]
            if(max<=mid) {
                count++
            }
            else {
                count = count + parseInt(max/mid) +(( max%mid)===0?0:1)
            }
            if(count>h) {
                return false
            }
        }
        return true
    }
    while(min<=max) {
        let mid = parseInt((min+max)/2)
        if(judge(mid)) {
            result = mid
            max = mid -1
        }
        else {
            min = mid + 1
        }
    }
    return result
};