算法入门

找出两个数中最小的：

let  minOf2=numbers=>number[0]<number[1]?number[0]:number[1]

再优化代码：

let minOf2=([a,b])=>a<b?a:b

(这种写法叫析构赋值)

找出三个数字里面最小的：

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

或者：

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

所有得出推理：

let minOf4=([a,b,c,d])=>{
              return minOf([a,minOf([b,c,d])])}

找出最小的数：

let min=(numbers)=>{
if(numbers.length>2){
return min([numbers[0],min(numbers.slice(1))])
}else{return Math.min.apply(null,numbers)}}

求正整数从小到大排序：

长度为2的数组的排序：

let sort2=([a,b])=>{
if(a<b){
return [a,b]
}else{return [b,a]}}

优化代码：

let sort2=([a,b])=>a<b?[a,b]:[b,a]

长度为3的数组排序：

let sort3=(numbers)=>{
     let index=minIndex([a,b,c])
     let min=numbers[index]numbers.splice(index,1)
     return [min].concat(sort2(numbers))}

//minIndex是假设的函数，能找出最小值的下标

任意长度数组排序：

let sort=(numbers)=>{
if(numbers.length>2){
let index=minIndex(numbers)
let min=numbers[index]
numbers.splice(index,1)
return [min].concat(sort(numbers))
}else{return numbers[0]<numbers[1]?numbers:numbers.reverse()
}}
let minIndex=(numbers)=>numbers.indexOf(min(numbers))

重写minIndex算法：

let minIndex=(numbers)=>
let index=0
for(let i=1;i<numbers.length;i++){
if(numbers[i]<numbers[index]){
index=i}
}
return index}

重写选择排序算法：

let sort = (numbers) => {
  for(let i=0; i< numbers.length -1; i++){
    console.log(`----`) //这个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(`swap ${index}: ${i}`)
      console.log(numbers)
    }
}
  return numbers
}

let swap = (array, i, j) => {
  let temp = array[i]
  array[i] = array[j]
  array[j] = temp
}
let minIndex = (numbers) => {
  let index = 0
  for(let i=1; i<numbers.length; i++){
    if(numbers[i] < numbers[index]){
      index = i
    }
  }
  return index
}

快速排序：

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) )
}

归并算法：

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))
}

计数排序：

用到哈希表做记录：

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}

计算时间复杂度：

选择排序：O(n^2)

快速排序：O(n log2n)

归并排序：O(n log2n)

计数排序：O(n+max)