练习：几种基础算法排序

1. 选择排序 sort

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
} //此时swap和minIndex还未实现

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
}

sort([2,8,5,7,1,4])//得到如下返回值
(6) [1, 2, 4, 5, 7, 8]

2. 快速排序quick sort

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

quickSort([2,8,5,7,1,4])//得到如下返回值
(6) [1, 2, 4, 5, 7, 8]

3. 并归排序merge sort

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

mergeSort([2,8,5,7,1,4])//得到如下返回值
(6) [1, 2, 4, 5, 7, 8]

4. 计数排序hash table

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
}

countSort([2,8,5,7,1,4])//得到如下返回值
(6) [1, 2, 4, 5, 7, 8]

• 计数排序的数据结构有所不同，使用了额外的hashTable，只遍历数组一遍，不过还要遍历hashTable，也就是“用空间换时间“