算法入门 ——4+4+1种

选择排序

选择最小的放在最前面

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(`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){
    console.log(`----`)
    console.log(arr)
    return arr
  }
  let pivotIndex = Math.floor(arr.length / 2);
  let pivot = arr.splice(pivotIndex,1)[0]
  console.log(`pivotIndex ${pivotIndex}`)
  console.log(`pivot ${pivot}`)
  let left = []
  let right = []
  for (let i = 0; i<arr.length; i++){
    if (arr[i] < pivot){
      left.push(arr[i])
      console.log(`left ${left}`)
    }else{
      right.push(arr[i])
      console.log(`right ${right}`)
    }
  }
  return quickSort(left).concat([pivot], quickSort(right))
}

归并排序

归并排序有些复杂，

• 大概就是一个一个细分，分到最后只有一个数字，一个数字它自己本身就是排好序的，
• 然后两个比较，组合（merge）成一个新的排好序的两个数的数组，
• 然后两个两个数字的组合进行组合（merge），
• 一次类推，拆开，再merge，最后排好

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))
  console.log(`----`)
  console.log(`left ${left}`)
  console.log(`right ${right}`)
  console.log(`arr ${arr}`)
  return merge(mergeSort(left),mergeSort(right))
  
  
}

let merge = (a, b) => {
  if (a.length === 0){
    return b
  }
  if (b.length === 0){
    return a
  }
  console.log(`a ${a}`)
  console.log(`b ${b}`)
  console.log(a[0] > b[0] ? 
         [b[0]].concat(merge(a ,b.slice(1))):
         [a[0]].concat(merge(a.slice(1),b)))

  return a[0] > b[0] ? 
         [b[0]].concat(merge(a ,b.slice(1))):
         [a[0]].concat(merge(a.slice(1),b))
}

计数排序

用哈希表做记录，然后把哈希表的key都打印出来

let countSort = arr => {
  let hashTable = {}, max = 0, result = []
  for(let i=0; i<arr.length; i++){  //遍历数组
    console.log(`----`)
    console.log(`arr[i] ${arr[i]}`)
    if(!(arr[i] in hashTable)){
      hashTable[arr[i]] = 1
    }else{
      hashTable[arr[i]] += 1
    }
    if(arr[i] > max){
      max = arr[i]
    }
  }
  console.log(`arr ${arr}`)
  for(let j=0; j<=max; j++){  // 遍历哈希表
    console.log(`result ${result}`)
    if(j in hashTable){
      for(let i=0; i<hashTable[j]; i++){  //预防有两个相同的数字
        result.push(j)
      }
    }
  }

  
  return result
}

其他排序

（一）冒泡排序

两两比较，大的往后放

（二）插入排序

一个一个比较，选择合适的地方插队进去

（三）希尔排序

（四）基数排序

把数字的个位十位百位依次比较，按顺序放进放出

堆排序