四种排序算法

选择排序

let arr = [2, 5, 4, 1, 3, 6, 8, 7]
let minIndex = (numbers) => {
  let index = 0
  for (let i = 1; i < numbers.length; i++) {
    if (numbers[index] > numbers[i]) {
      index = i
    }
  }
  return index
}
let swap = (numbers, i, j) => {
  let temp = numbers[i]
  numbers[i] = numbers[j]
  numbers[j] = temp
}
let sort = (numbers) => {
  for (let i = 0; i < numbers.length - 1; i++) {
    let index = minIndex(numbers.slice(i)) + i
    if (index !== i) {
      swap(numbers, index, i)
    }
  }
  return numbers
}
console.log(sort.call(null, arr))

快速排序

let arr = [3, 6, 8, 4, 7, 1, 5]
let quickSort = (arr) => {
  if (arr.length <= 1) { return arr }
  let baseIndex = Math.floor(arr.length / 2)
  let base = arr.splice(baseIndex, 1)[0]
  console.log(base)
  let left = []
  let right = []
  for (let i = 0; i < arr.length; i++) {
    arr[i] > base ? right.push(arr[i]) : left.push(arr[i])
  }
  return quickSort(left).concat([base], quickSort(right))
}
console.log(quickSort(arr))

归并排序

let arr = [3, 1, 6, 7, 4, 5, 10]
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 mergeSort = (arr) => {
  if (arr.length === 1) { return arr }
  let left = arr.slice(0, Math.floor(arr.length / 2))
  let right = arr.slice(Math.floor(arr.length / 2))
  return merge(mergeSort(left), mergeSort(right))
}
console.log(mergeSort.call(null, arr))

计数排序

let a = [1, 4, 6, 4, 3, 2, 7, 4, 100]
let countSort = (arr) => {
  let hashTable = {}
  let max = 0
  let result = []
  for (let i = 1; 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] }
  }
  console.log(max)
  for (let j = 0; j <= max; j++) {
    for (let i = 0; i < hashTable[j]; i++) {
      if (j in hashTable) {
        result.push(j)
      }
    }
  }
  return result
}
console.log(countSort.call(null, a))