【前端算法系列】搜索

顺序搜索

遍历数组，找到跟目标相等的元素，就返回它的下标，遍历结束后，没找到就返回-1

// 时间复杂度：O(n) 循环
Array.prototype.sequentialSearch = function (item) {
  for(let i=0;i<this.length;i+=1){
    if(this[i] === item){
      return i
    }
  }
  return -1
};
const arr = [5, 4, 3, 2, 1]
arr.sequentialSearch(3)

二分搜索

在有序数组中查找某个元素的算法（必须是有序)

1）从数组的中间元素开始，如果中间元素正好是目标值，则搜索结束
2）如果目标值大于或小于中间元素，则在大于或小于中间元素的那一半数组中搜索
就是不停地折半搜索

/* 时间复杂度：每一次比较都使搜索范围缩小一半，所以是O(logN)，
  凡是劈成两半都是logN，logN比N小
*/
Array.prototype.binarySearch = function (item) {
  let low = 0 
  let high = this.length-1
  while(low<=high){
    const mid = Math.floor((low+high)/2)
    const element = this[mid]
    if(element<item){
      low = mid+1
    }else if(element>item){ // 中间值大于我想要的
      high = mid-1
    }else{
      return mid
    }
  }
  return -1
};
const arr = [5, 4, 3, 2, 1]
arr.binarySearch(3)

21. 合并两个有序链表

/*  时间复杂度：O(n) n是l1、l2长度之和
    空间复杂度：O(1) 新建的临时变量都是指针，不是数组/矩阵/链表，只是常量级别，不会增加
*/
var mergeTwoLists = function(l1, l2) {
    const res = new ListNode(0)
    // 定义三个指针
    let p = res 
    let p1 = l1
    let p2 = l2
    while(p1&&p2){
        if(p1.val<p2.val){
            p.next = p1 // 把p1接到新链表的节点上
            p1 = p1.next // 节点用过不能再用了，往后移动一位
        }else{
            p.next = p2
            p2 = p2.next
        }
        p = p.next // p永远指向新链表的最后一位
    }
    if(p1){ // 如果p1还有值，就街道新链表后面
        p.next = p1
    }
    if(p2){ 
        p.next = p2
    }
    return res.next
};

374. 猜数字大小

使用二分搜索

var guessNumber = function(n) {
    let low = 1
    let high = n
    while(low<=high){
        const mid = Math.floor((low+high)/2)
        /* guess函数会返回3个结果 -1，1，0，所以通过3个结果判断
            -1 即mid比较小
            1 即mid比较大
            0 即结果
        */
        const res = guess(mid) 
        if(res===0){
            return mid
        }else if(res===1){
            low = mid+1
        }else{
            high = mid-1
        }
    }
};