链接记录

https://www.bianchengquan.com/ 行业/博客标签
https://processon.com/ 在线流程图
https://quicktype.io/ json文件转ts代码

//防抖
function debounce(func, wait) {
    let timeout;
    return function () {
        const context = this;
        const args = arguments;
        clearTimeout(timeout)
        timeout = setTimeout(function(){
            func.apply(context, args)
        }, wait);
    }
}

//节流
function throttle(func, wait) {
  let timeout;
  return function () {
    const context = this;
    const args = arguments;
    if (!timeout) {
      timeout = setTimeout(function () {
        timeout = null;
        func.apply(context, args)
      }, wait)
    }

  }
}

冒泡排序

function bubleSort(arr){
  var len = arr.length;
  for(let outer = len;outer>=2;outer--){
    for(let inner = 0;inner<=outer-1;inner++){
      if(arr[inner]>arr[inner+1]){
        [arr[inner],arr[inner+1]] = [arr[inner+1,arr[inner]];
      }
    }
  }
  return arr;
}

选择排序

function selectSort(arr){
  var len = arr.length;
  for(let outer = 0;outer<len-1;outer++){
    for(let inner = outer;inner<len;inner++){
      if(arr[j]<arr[i]){
        [arr[i],arr[j]] = [arr[j],[i]] 
      }
    }
  }
  return arr
}

快速排序

function quickSort(arr){
  if(arr.length<=1){
    return arr
  }
  let left = [];
  let right = [];
  let current = arr.splice(0,1);
  for(let i =0;i<arr.length;i++){
    if(arr[i] < current){
      left.push(arr[i])
    }else{
      right.push(arr[i])
    }
  }
  return quickSort(left).concat(current,quickSort(right));
}

扁平化数组

Array.prototype.flat = function(){
  var arr =[];
  this.forEach((item,idx)=>{
    if(Array.isArray(item)){
      arr = arr.concat(item.flat())
    }else{
      arr.push(item)
    }
  })
  return arr;
}

二分查找

function binaryFind(arr,target){
  var low = 0,
      hight = arr.length-1,
      mid;
  while(low<=hight){
    mid = Math.floor((low + hight)/2);
    if(target === arr[mid]){
      return `找到了${target},在第$[mid +1]个元素`
    }
    if(target >mid){
      low = mid +1;
    } else if(target < arr[mid]){
      hight = mid -1;
    }
  }
  return -1;
}

外循环遍历数组的每一项，内循环则用于比较元素。
递归，其实就是自己调用自己。
有两个相同的数A和B，在排序之前A在B的前面，而经过排序之后，B跑到了A的前面，对于这种情况的发生，我们管他叫做排序的不稳定性