JS算法合集

一、二分法

• 方法介绍：
  该方法为二分法查找，实现通过二分法快速找到元目标素在数组中的位置。
• 思路：
  将数组从中间分为两部分，用中间元素和目标元素比较，如果比目标元素小，则再把数组后半部分分为两部分....,从而避免挨个遍历比较。
• 输入：
  paraArr 有序数组，paraFind 要找的目标元素。
• 输出：
  要找的元素在数组中的位置，如果没找到返回null。
• 时间复杂度：O(logn)。

const Bisection = (paraArr, paraFind) => {
  if (!paraArr.length || paraArr.length <= 1) {
    return null
  }
  let low = 0
  let high = paraArr.length - 1
  while (low <= high) {
    let mid = parseInt((low + high) / 2)
    if (paraArr[mid] == paraFind) {
      return mid
    } else if (paraArr[mid] > paraFind) {
      high = mid - 1
    } else {
      low = mid + 1
    }
  }
  return null
}
let arr = [1, 2, 3, 4, 5]
let find = 8
let index = Bisection(arr, find)
console.log(index)

二、选择排序

• 方法介绍： 该方法为选择排序，实现数组由小到大排序。
• 思路： 遍历数组，找到最小的元素，放到新的数组，再遍历去除最小元素后的数组，找到最小的元素...
• 输入： paraArr 数组。
• 输出： 由小到大排序的数组。

• 时间复杂度： O(n^2)。

  //深拷贝
  import { deepCopy } from './utils'
  //获取数组中最小元素
  const getMin = (arr) => {
  let min = 0
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] < arr[min]) {
      min = i
    }
  }
  return min
  }
  const SelectionSort = (paraArr) => {
  if (!paraArr.length || paraArr.length <= 1) {
    return null
  }
  let resArr = []
  let arr = deepCopy(paraArr)
  for (let i = 0; i < paraArr.length; i++) {
    let index = getMin(arr)
    resArr.push(arr[index])
    arr.splice(index, 1)
  }
  return resArr
  }
  let arr = [7, 10, 3, 6, 5]
  let resArr = SelectionSort(arr)
  console.log(resArr)

三、求两个正整数的最大公约数

欧几里得定理（辗转相除法）：两个正整数a和b（a>b），它们的最大公约数等于a除以b的余数c与b之间的最大公约数。
公式：gcb(a,b)=gcb(b,a%b)

**证明过程：**
d=gcb(a,b);  //d为a,b的最大公约数
a=bk+r;       
r=a-bk;   
r/d=a/d-b*k/d;   //两边同时除以d,a/d是整数，b/d是整数
d | r  //因此r/d是整数，因此d是整除于r的
所以d是a,b,r的公约数，d是a,b的最大公约数，且r<b,因此d是b和r的最大公约数d=gcb(b,r)=>d=gcb(b,a%b)
gcb(a,b)=gcb(b,a%b)

• 方法介绍：该方法为通过递归、欧几里得算法获取最大公约数。
• 思路：欧几里得算法。
• 输入：paraA paraB 为正整数，且paraA>paraB。
• 输出：paraA paraB的最大公约数。

const MaxCommonDivisor = (paraA, paraB) => {
  return paraB == 0 ? paraA : MaxCommonDivisor(paraB, paraA % paraB)
}
let res = MaxCommonDivisor(377, 319)
console.log(res)

四、快速排序

• 方法介绍：该方法为快速排序，实现数组由小到大排序。
• 思路：
  选取一个基准值base，遍历数组;
  找到比基准值小的元素，放到新的数组，并排序，得到minArr;
  找到比基准值大的元素，放到新的数组，并排序maxArr。
  拼起来：得出minArr+base+maxArr
• 输入：paraArr 数组。
• 输出：由小到大排序的数组。

• 时间复杂度：最遭情况O(n^2) 平均情况O(n log n)。

  //深拷贝
  import { deepCopy } from './utils'
  const QuickSort = (paraArr) => {
  if (!paraArr.length || paraArr.length < 2) {
    return paraArr
  }
  let base = paraArr[0]
  let minArr = []
  for (let i = 0; i < paraArr.length; i++) {
    let item = paraArr[i]
    if (item < base) {
      minArr.push(item)
    }
  }
  minArr = QuickSort(minArr)
  let maxArr = []
  for (let i = 0; i < paraArr.length; i++) {
    let item = paraArr[i]
    if (item > base) {
      maxArr.push(item)
    }
  }
  maxArr = QuickSort(maxArr)
  
  let resArr = deepCopy(minArr)
  resArr.push(base)
  resArr = resArr.concat(maxArr)
  return resArr
  }
  let arr = [7, 10, 3, 6, 5]
  let resArr = QuickSort(arr)
  console.log(resArr)
  

  五、递归数组求和

• 方法介绍：该方法为通过递归求和。
• 思路：递归取出第一项与数组剩下的总数求和。
• 输入：paraArr 为数组，每项为整数。

• 输出：paraArr各项求和后的数。

  const Sum = (paraArr) => {
  if (!paraArr.length) {
    return 0
  } else {
    return paraArr[0] + Sum(paraArr.slice(1))
  }
  }
  let res = Sum([1, 2, 3])
  console.log(res)