如果覺得還有點用食铐，請您給我一個贊！您的贊是我堅持下去的動力僧鲁！

深度遍歷

拿DOM作為遍歷對象虐呻，實現(xiàn)2種遍歷方法案例

/**
原理：節(jié)點的子節(jié)點先遍歷，再遍歷同級節(jié)點
node:一個節(jié)點
fn:每個節(jié)點需要執(zhí)行的操作
**/
async deep(node,fn){
  await fn(node);
  if(node.children){
    for(let i=0;i<node.children.length;i++){
      await this.deep(node.children[i],fn);
    }
  }
}

廣度遍歷

/**
原理：節(jié)點的同級節(jié)點先遍歷寞秃，再遍歷子節(jié)點
node:一個節(jié)點
fn:每個節(jié)點需要執(zhí)行的操作
**/
async wide(node,fn){
  let queue = [];
  queue.push(node);
  while (queue.length != 0) {
    let item = queue.shift();
    await fn(item);
    for (let j = 0; j < item.children.length; j++) {
      queue.push(item.children[j])
    }
  }
}

防抖

• 原理：函數(shù)在調(diào)用倒計時n時間內(nèi)沒有重復(fù)調(diào)用斟叼，則執(zhí)行函數(shù)，不然重新倒計時
• 應(yīng)用場景：常用在鼠標(biāo)滾動等一些超高頻操作下需要執(zhí)行函數(shù)刷新時

function run(fn,ms){
  let tm=null;
  return function(){
    clearTimeout(tm);
    tm=setTimeout(()=>{
      fn.apply(this, arguments);
    },ms)
  }
}

節(jié)流

• 原理：當(dāng)函數(shù)未執(zhí)行完前重復(fù)調(diào)用將無效
• 應(yīng)用場景：常用在定時刷新

function run(fn,ms){
  let canrun=true;
  return function(){
    if(!canrun)return;
    canrun=false;
    tm=setTimeout(()=>{
      fn.apply(this, arguments);
      canrun=true;
    },ms)
  }
}

優(yōu)化版冒泡排序

/**
 特點:優(yōu)化后遍歷次數(shù)可以較小春寿，基本滿足前端常見排序要求了
 **/
function bubbleSort(arr) {
  let len = arr.length;
  let k = len - 1;
  let isSwap = false;//是否交換標(biāo)記
  let pos = 0;//最后一次交換位置
  let temp = null;
  for (let i = 0; i < len; i++) {
    isSwap = false;
    pos = 0;
    for (let j = 0; j < k; j++) {
      if (arr[j] > arr[j + 1]) {
        temp = arr[j + 1];
        arr[j + 1] = arr[j];
        arr[j] = temp;
        pos = j;
        isSwap = true;
      }
    }
    if (!isSwap) { return arr; }
    k = pos;
  }
  return arr;
}

選擇排序

/**
特點：最大數(shù)據(jù)交換次數(shù)是固定的數(shù)組長度相等朗涩，遍歷次數(shù)永遠(yuǎn)固定
 **/
function selectionSort(arr) {
  let len = arr.length;
  let minIndex, temp;
  for (let i = 0; i < len - 1; i++) {
    minIndex = i;
    for (let j = i + 1; j < len; j++) {
      if (arr[j] < arr[minIndex]) {   //尋找最小的數(shù)
        minIndex = j;         //將最小數(shù)的索引保存
      }
    }
    if(i!=minIndex){
      temp = arr[i];
      arr[i] = arr[minIndex];
      arr[minIndex] = temp;
    }
  }
  return arr;
}

快速排序

function quickSort(arr){  
  if (arr.length <= 1) {  
    return arr;  
  }  

  //取出數(shù)組中間的一位作為比較對象 如 [5,0,6,3,8] 則取出6，數(shù)組變?yōu)閇5,0,3,8]
  var povitIndex = arr.length>>>1;  
  var povit = arr.splice(povitIndex, 1)[0];  

  //接下來就是遍歷[5,0,3,8]將比6小的數(shù)放入到leftArr,相反放入rightArr
  var leftArr = [], rightArr = [];  
  for (var i = arr.length - 1; i >= 0; i--) {  
    if (arr[i] < povit) {  
        leftArr.push(arr[i]);  
    } else {  
        rightArr.push(arr[i]);  
    }  
  }  
  //遍歷下來后生成了 leftArr[5,0,3],rightArr[8]

  //接下來遞歸調(diào)用绑改，繼續(xù)將leftArr和rightArr這2個數(shù)組重復(fù)以上的操作
  //最終將leftArr+povit+rightArr 合并為一個數(shù)組即得最終排序后結(jié)果
  return quickSort(leftArr).concat([povit], quickSort(rightArr));  
}  

二分查找 - 適用于對排序后的數(shù)組,時間復(fù)雜度O(logn)

/**
* arr:[1,2,3,4]排序后的數(shù)組
* target:目標(biāo)尋找的值
* type:left|right|''  查詢方式谢床，left:查詢最左值兄一，right:查詢最右值
*/
function bsearch(arr, target, type){
    let begin = 0;
    let end = arr.length;
    let idx =-1;
    
    while(begin < end ) {
        let mid = (begin + end) >>> 1;
        if(arr[mid] == target) {
            if(type === 'right'){
                begin =  mid+1;
            }
            else if(type === 'left'){
                end =  mid;
            }else{
                return mid;
            }
            
        }
        else if(arr[mid] > target) {
            end = mid;
        }
        else if(arr[mid] < target) {
            begin = mid + 1; 
        }
    }
    
    if(type === 'right'){
        idx = arr[begin-1]===target?begin-1:-1;
    }
    else if(type === 'left'){
        idx =  arr[begin]===target?begin:-1;
    }
    console.log(`${idx}位`)
    return idx;
    
}
bsearch([1,4,5,7,11],5); //2
bsearch([1,3,3,3,5],3,'left')；//1
bsearch([1,3,3,3,5],3,'right'); //3