沐鳴首頁_Js常用的算法教程

深度遍歷

拿DOM作為遍歷對象，實現2種遍歷方法案例

/**
原理：節點的子節點先遍歷，再遍歷同級節點
node:一個節點
fn:每個節點需要執行的操作
**/
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);
    }
  }
}

廣度遍歷

/**
原理：節點的同級節點先遍歷，再遍歷子節點
node:一個節點
fn:每個節點需要執行的操作
**/
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])
    }
  }
}

防抖

• 原理：函數在調用倒計時n時間內沒有重複調用，則執行函數，不然重新倒計時
• 應用場景：常用在鼠標滾動等一些超高頻操作下需要執行函數刷新時

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

節流

• 原理：當函數未執行完前重複調用將無效
• 應用場景：常用在定時刷新

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

優化版冒泡排序

/**
 特點:優化后遍歷次數可以較小，基本滿足前端常見排序要求了
 **/
function bubbleSort(arr) {
  let len = arr.length;
  let k = len - 1;
  let isSwap = false;//是否交換標記
  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;
}

選擇排序

/**
特點：最大數據交換次數是固定的數組長度相等，遍歷次數永遠固定
 **/
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]) {   //尋找最小的數
        minIndex = j;         //將最小數的索引保存
      }
    }
    if(i!=minIndex){
      temp = arr[i];
      arr[i] = arr[minIndex];
      arr[minIndex] = temp;
    }
  }
  return arr;
}

快速排序

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

  //取出數組中間的一位作為比較對象 如 [5,0,6,3,8] 則取出6，數組變為[5,0,3,8]
  var povitIndex = Math.floor(arr.length/2);  
  var povit = arr.splice(povitIndex, 1)[0];  

  //接下來就是遍歷[5,0,3,8]將比6小的數放入到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]

  //接下來遞歸調用，繼續將leftArr和rightArr這2個數組重複以上的操作
  //最終將leftArr+povit+rightArr 合併為一個數組即得最終排序后結果
  return quickSort(leftArr).concat([povit], quickSort(rightArr));  
}  

站長推薦

1.雲服務推薦: 國內主流雲服務商，各類雲產品的最新活動，優惠券領取。地址：阿里雲騰訊雲華為雲

2.廣告聯盟: 整理了目前主流的廣告聯盟平台，如果你有流量，可以作為參考選擇適合你的平台點擊進入

鏈接: http://www.fly63.com/article/detial/7324