JS算法 -- 持续更新

• 求一个数是否是素数? / 10000以内哪些是素数?
  注意点：排除1、2、偶数，在平方根以内循环查找

• [[1,2], [[3,4],5]] => [1,2,3,4,5]

function flatten(arr){
	return [].concat(
		...arr.map(x => {
			return Array.isArray(x)?flatten(x):x
		})
	)
}

• 节流 – eg: 500ms内值执行一次

function throttle(func, delay = 500){
	let runing = false
	return function(...args){
		if (runing) return
		runing = true
		func(...args)
		setTimeout(() => { runing = fase }, delay)
	}
}

• 防抖 – eg：高频执行操作完，100ms后真正执行，如果这100ms又操作重新计时

function debounce(func, delay){
	let timer = null;
	return function(...args){
		clearTimeout(timer)
		timer = setTimeout(() => {
			// func(...args)
			func.apply(this, ...args)
		}, delay)
	}
}

• 柯里化

const curry = (func) => {
	const g = () => {}
	return g
}

• 十大经典排序
  https://www.jianshu.com/p/1af509b2be08
  https://www.cnblogs.com/onepixel/articles/7674659.html
  

1. 冒泡排序
   对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端， 最终达到完全有序

// 冒泡排序
function bubblingSort (arr) {
  for (var i = arr.length - 1; i >= 0; i--) {
    for (var j = 0; j < i; j++) {
      if (arr[j] > arr[j+1]) {
        var temp = arr[j+1]
        arr[j+1] = arr[j]
        arr[j] = temp
      }
    }
  }
  return arr
}
console.log(bubblingSort([3, 62, 3, 2, 8, 24, 65]))

2. 选择排序
   每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止。

// 选择排序：从当前后面选择个最小的和当前调换
function selectSort(arr){
  for (var i = 0; i < arr.length - 1; i++) {
    var min = i // 每次循环min=i
    for (var j = i+1; j < arr.length; j++) {
      if (arr[min] > arr[j]) {
        min = j
      }
    }
    var temp = arr[i]
    arr[i] = arr[min]
    arr[min] = temp
  }
  return arr
}
console.log(selectSort([3, 62, 3, 2, 8, 24, 65]))

3. 插入排序
   每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止

function insertSort(array) {

  let length = array.length;
  
  // 如果不是数组或者数组长度小于等于1，直接返回，不需要排序 
  if (!Array.isArray(array) || length <= 1) return;

  // 循环从 1 开始，0 位置为默认的已排序的序列
  for (let i = 1; i < length; i++) {
    let temp = array[i]; // 保存当前需要排序的元素
    let j = i;

    // 在当前已排序序列中比较，如果比需要排序的元素大，就依次往后移动位置
    while (j -1 >= 0 && array[j - 1] > temp) {
      array[j] = array[j - 1];
      j--;
    }
    // 将找到的位置插入元素
    array[j] = temp;
  }
  return array;
}

4. 快速排序

// 快速排序：以第一个值为标准，小于它的放左边，大于它的放右边
function fastSort (arr) {
  if (arr.length == 0) return arr
  var left = [], right = []
  for (var i = 1; i < arr.length; i++) {
    var base = arr[0]
    if (arr[i] <= base) {
      left.push(arr[i])
    } else {
      right.push(arr[i])
    }
  }
  return fastSort(left).concat(arr[0], fastSort(right))
}
console.log(fastSort([3, 62, 3, 2, 8, 24, 65]))

5. 希尔排序
   把数组按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的元 素越来越多，当增量减至1时，整个数组恰被分成一组，算法便终止。

6. 二分查找法

/**
* arr:有序数组
* 要找的目标数据
*/
function (nums, target) {
	let left = 0, right = nums.length;
	while (left <= right) {
		let mid = Math.floor((left+right)/2)
		if (nums[mid] === target) {
			return mid
		}
		if (target > nums[mid]) {
			left = mid + 1
		} else {
			right = mid - 1
		}
	}
    return -1
}