算法与数据结构，排序算法-下

选择排序

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
}

总结

• 选择排序：每次选择最小放前面，后面再做选择，min放前面后，选到最后没得选，排完
• 快速排序：以某个同学为基准，小的往前跑，大的往后跑，指这个同学排后，再循环这个做法，直到每个同学都被指定过
• 归并排序：手指指定排序，指中对象进行排序，小的拿到另外开的一个数组，然后再一次手指指下一位数字排序
• 计数排序：用哈希表的key:value

时间复杂度

• 选择排序：O(n^2)
• 快速排序：O(nlog2n) //树状图 n/b^n
• 归并排序：O(nlog2n)
• 计数排序：O(n+max-min(默认min为0))

其他排序

• 冒泡排序：https://visualgo.net/zh/sorting
• 插入排序：https://visualgo.net/zh/sorting 点INS
• 希尔排序：https://sorting.at/ 选择Shell Sort
• 基数排序：https://visualgo.net/zh/sorting 点RAD