前端简单算法

1、二分查找

704. 二分查找

-- 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

思路：每次都取数组的中值，如果相等则返回，如果不等，判断是大于目标值还是小于目标值，分别移动索引 mid - 1 或者 mid + 1

function search(nums, target) {
    return BinarySearch(nums, start, end, target)
}

function BinarySearch(arr, s, e, target) {
  while(e - s > 0) { // 数组中起码有两个元素
      let mid = Math.floor((s + e) / 2);
      if(arr[mid] === target) {
          return mid
      } else if(arr[mid] > target) {
          return BinarySearch(arr, s, mid - 1, target)
      } else {
          return BinarySearch(arr, mid + 1, e, target)
      }
  } 
  if(arr[s] === target) return s // 当数组只有一个元素时，如果相等就返回
  return -1  // 没有就返回-1
}

278. 第一个错误的版本

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

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

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

思路：要求尽量少调用isBadVersion,那么就使用二分查找，每次获取中值，如果中值是错误的版本，缩小范围到 0 到 中值，否则就是 中值 到 n

var solution = function (isBadVersion) {
    return function (n) {
        return BinarySearch(1, n, isBadVersion)
    };
};

function BinarySearch(s, e, isBadVersion) {
    while (s < e) {
        let mid = Math.floor((e + s) / 2)
        if (isBadVersion(mid)) {
            return BinarySearch( 0, mid, isBadVersion) // 不应该是0 - mid - 1,因为mid也是错误的版本
        } else {
            return BinarySearch( mid + 1, e, isBadVersion)
        }
    }
    if (e === s) return s
}

时间复杂度O（logn）,假设X次找到改值, n/2$^x$ = 1
那么x=O(logn)
那么空间复杂度为O(1)

35. 搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。
思路是: 二分查找，如果有，就直接返回索引，如果没有，当 start === end 时,要插入的位置就在那附近，要么是 start 或 start + 1

var searchInsert = function (nums, target) {
    return BinarySearch(nums, 0, nums.length - 1, target);
};

function BinarySearch(arr, s, e, target) {
    while (e - s > 0) {
        let mid = Math.floor((s + e) / 2);
        if (arr[mid] === target) {
            return mid;
        } else if (arr[mid] > target) {
            return BinarySearch(arr, s, mid - 1, target);
        } else {
            return BinarySearch(arr, mid + 1, e, target);
        }
    }
    // 循环结束还没有找到
    if (target > arr[s]) {
        return s + 1;
    } else {
        return s;
    }
}

时间复杂度为O(logn) 跟上面一样
原地排序算法