算法

排序

• JS代码位置

最好写在body标签闭合之前，这样浏览器会在加载脚本之前，解析和显示HTML，有利于提升页面的性能

• 快排

var quickSort = function(arr){
    //检查数组的元素个数，如果小于等于1，就返回
    var len = arr.length;
    if(len <= 1){
      return arr
    }
    //接着，选择"基准"（pivot），并将其与原数组分离，再定义两个空数组，用来存放一左一右的两个子集。
    var pivotIndex = Math.floor(arr.length / 2);
　　var pivot = arr.splice(pivotIndex, 1)[0];
    var left  = [];
        right = [];
    // 然后，开始遍历数组，小于"基准"的元素放入左边的子集，大于基准的元素放入右边的子集。
    arr.forEach((item)=>{
      if(item < pivot){
        left.push(item)
      }else{
        right.push(item)
      }
    })
    //合并左右数组
    return quickSort(left).concat([pivot],quickSort(right))
}
var arr = [3,77,66,55]
console.log(quickSort(arr))//[3,55,66,77]

贪心算法

 function MinCoins(coins){
  var coins = coins;
  this.change = function(num){
    var res   = [],
        total = 0;

    for(var i = coins.length-1;i>=0;i--){
      var coin = coins[i]
      while(total+ coin <= num){
        res.push(coin)
        total += coin
      }
    }
    return res;
  }
 }
 var minCoins = new MinCoins([1,5,10,25])
 var a = minCoins.change(36)
  console.log(a)

• 冒泡 排序

  function bubbleSort(arr){
    var len = arr.length;
    for(var i=0;i<len;i++){
      for(var j=0;j<len-1-i;j++){
        if(arr[j]>arr[j+1]){
          var temp = arr[j]
          arr[j] = arr[j+1]
          arr[j+1]=temp
        }
      }
    }
    return arr
  }

*选择排序

 function selectSort(arr){
    var len=arr.length;
    var minIndex,temp;
    console.time('选择排序耗时')；
    for(i=0;i<len-1;i++){
        minIndex=i;
        for(j=i+1;j<len;j++){
            if(arr[j]<arr[minIndex]){
                minIndex=j;
            }
        }
    temp=arr[i];
    arr[i]=arr[minIndex];
    arr[minIndex]=temp;
    }
    console.timeEnd('选择排序耗时');
    return arr;
}

插入排序

function insert(arr){
  var len = arr.length,
      temp,
      j;
  for(var i=1;i<len;i++){
    temp = arr[i]
    j = i
    while(arr[j-1]>temp&&j>0){
      arr[j] = arr[j-1]
      j--;
    }
    arr[j] = temp
  }
  return arr
}

• 归并排序

function merge(leftArr, rightArr){  
    var result = [];  
    while (leftArr.length > 0 && rightArr.length > 0){  
      if (leftArr[0] < rightArr[0])  
        result.push(leftArr.shift()); //把最小的最先取出，放到结果集中   
      else   
        result.push(rightArr.shift());  
    }   
    return result.concat(leftArr).concat(rightArr);  //剩下的就是合并，这样就排好序了  
}  

function mergeSort(array){  
    if (array.length == 1) return array;  
    var middle = Math.floor(array.length / 2);       //求出中点  
    var left = array.slice(0, middle);               //分割数组  
    var right = array.slice(middle);  
    return merge(mergeSort(left), mergeSort(right)); //递归合并与排序  
}  

• 二分搜索

function binarySearch(arr,target){
  arr.sort((a-b)=>{a-b})
  var low = 0,
      heigh =arr.length-1,
      mid;
  while(low<=heigh){
    mid = Math.floor(low+heigh/2),
    if(target<arr[mid]){
      heigh = mid - 1
    }else if(target>height){
      low = mid + 1
    }else{
      return mid
    }
  }
  return -1;
}

• DFS递归

function DFS(node){
  var res = []
  while(node!=null){
    res.push(node);
    children = node.children;
    for(var i=0;i<children.length;i++){
      node = children[i]
      DFS(node)
    }
  }
  return res;
}

#####BFS