1.算法到底是什么东西

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。

2.找出最小值

上面的我是从百度百科上抄写下来的,一看很蒙蔽,接下来我开始举例来说明.

2.1找出两个数字的最小值

 let minOf2=(numbers)=>{
    if(numbers[0])<numbers[1]){
       return numbers[0];
    }else{
        return numbers[1] ;
    }
}
//可以优化代码,问号冒号表达式
let minOf2=numbers=>{
    numbers[0]<numbers[1]?numbers[0]:numbers[1] 
//可以再进行优化
let minOf2=([a,b]) => a<b?a:b

2.2找出三个数字的最小值

let minOf3 = ([a,b,c])=>{
     return minOf2([minOf2[a,b],c])

2.3推理求四个数字的最小值

 let minOf4=([a,b,c,d])=>{
    return minOf2([a,minOf3([b,c,d])])

2.4利用递归求任意数值的最小值

 let min=(numbers) =>{
    if(numbers.length>2){
        return min([numbers[0],min(numbers.slice(1))])
    }else{
        return Math.min.apply(null,numbers)//求两个数字的最小值的API
    }

3.选择排序

思路：
第一轮，找到最小的元素，和数组第一个数交换位置。
第二轮，找到第二小的元素，和数组第二个数交换位置.
直到最后一个元素，排序完成。
动画演示：
https://img-blog.csdnimg.cn/20200911232439594.gif#pic_center
实现代码：

//递归办法实现
let sort = (numbers) => {
  if(numbers.length > 2){
  let index = minIndex(numbers)
  let min = numbers[index]
  numbers.splice(index, 1)
////从numbers里面删除min
   return [min].concat(sort(numbers))
 }else{
   return numbers[0]<numbers[1] ? numbers :
numbers.reverse()
  }
}
//----循环方法实现----
//第一步用循环找出数组里面最小的数字的索引
 let minIndex=(numbers)=>{
  let index = 0
  for(let i=1;i<numbers.length;i++){
      if(numbers[i]<numbers[index]){
         index = i 
      }
    }
   return index 
} 
//第二步如何实现选择排序,让A和B交换位置
let swap =(array,i,j)=>{              
    let temp=array[i]  
    array[i]=array[j]     
    array[j]=temp   
}
//第三步循环写法
 let sort = (numbers)=>{
    for(let i=0;i<numbers.length-1;i++){
        console.log(`----`)
        console.log(`i:${i}`)
        let index=minIndex(numbers.slice(i))+i
        console.log(`index:${index}`)
        console.log(`min:${numbers[index]`)
        if(index!==i){
            swap(numbers,index,i)
            console.log(` ${index}: ${i}`) 
            console.log(numbers)
        }
     
    }
    return numbers
}

4.快速排序

快排，面试最喜欢问的排序算法。这是运用分治法的一种排序算法。
思路：
想象自己是体育委员，对面的同学就是数组，之后说以某某某为基础小的去前面，大的去后面，之后在重复这个过程。
动画演示：
https://image-static.segmentfault.com/297/881/2978812888-57dcd3a503e76_fix732
代码实现：

let quickSort = arr => {
　　if (arr.length <= 1) { return arr; }
　　let pivotIndex = Math.floor(arr.length / 2);
　　let pivot = arr.splice(pivotIndex, 1)[0];
　　let left = [];
　　let right = [];
　　for (let i = 0; i < arr.length; i++){
　　　　if (arr[i] < pivot) { left.push(arr[i])
　　　　} else { right.push(arr[i]) }
　　}
　　return quickSort(left).concat(
             [pivot], quickSort(right) )
}

5.归并排序

归并排序就是假设你是体育委员，左边一半排好序，右边一半排好序，之后合并这个很神奇吧。

图片.png
动画演示：
https://image-static.segmentfault.com/334/624/3346244490-57dcd3a4bbfdc_fix732
代码实现：

let mergeSort = arr =>{
  let k = arr.length
  if(k===1){return arr}
  let left = arr.slice(0, Math.floor(k/2))
  let right = arr.slice(Math.floor(k/2))
  return merge(mergeSort(left), mergeSort(right))
}
let merge = (a, b) => {
  if(a.length === 0) return b
  if(b.length === 0) return a
  return a[0] > b[0] ?
     [b[0]].concat(merge(a, b.slice(1))) :
     [a[0]].concat(merge(a.slice(1), b))
}

6.计数排序

思路：
用一个哈希表做记录，发现数字N就记1，如果再次发现N就加1；最后把哈希表的Key全部打印出来，假设N：m,那么N需要打印m次。
动图演示：
https://visualgo.net/zh/sorting
代码实现：

let countSort = arr =>{
  let hashTable = {}, max = 0, result = []
  for(let i=0; i<arr.length; i++){ // 遍历数组
    if(!(arr[i] in hashTable)){ // 视频中这一行写错
      hashTable[arr[i]] = 1
    }else{
      hashTable[arr[i]] += 1
    }
    if(arr[i] > max) {max = arr[i]}
  }
  for(let j=0; j<=max; j++){ // 遍历哈希表
    if(j in hashTable){
      for(let i = 0; i<hashTable[j]; i++){
        result.push(j)
      }
    }
  }
  return result
}

本文为本人的原创文章，著作权归本人和饥人谷所有，转载务必注明来源.
参考文章：https://visualgo.net/zh/sorting