简析选择，快速，归并，计数四种排序算法

一、选择排序

选择排序算法：在一组数组中，每次找到最小的数，提到前面来，然后对后面的数组做同样的事，排到只剩下两个数时，对比后把小的放前面即完成数组的排序。故排序数组的重点是找最小数的方法，利用递归法表示代码，（可用代入法和调用栈快速理解递归，调用栈即是函数调用函数）

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

找到最小的数后，对后续的排序就简单很多:

let minIndex = (numbers) =>{
   numbers.indexOf(min(numbers))
}
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) => {
   let index = 0
   for(let i=1; i<numbers.length; i++){
      if(numbers[i] < numbers[index]){
         index =i
      }
   }
   return index
}

优化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
}

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
}

选择排序的实际按复杂度一般为 n^2 。

二、快速排序

快速排序的思路是多次采用以某数为基准的方法，小的去前面，大的去后面，此数即已排好序，依次每一个数都点一下当基准，这些数即排好序。

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] < pivor){
          left.push(arr[i])
       } else { right.push(arr[i]) }
   }
   return quickSort(left).concat(
      [pivot],quickSort(right) )
}

快速排序的时间复杂度为：nlog2n。

三、归并排序

选择排序的思路是将数组分成两部分，默认这两部分是排好序的，再将两组数组分成四组数组，重复此操作，直到分出只剩一个数的数组，然后对已排好序的两个一个数的数组进行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.slic(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))
}

归并排序的时间复杂度为：nlog2n。

四、计数排序

计数排序的思路是用一个哈希表做记录，发现数字N就记录N:1，如果再次发现N就加1，最后把哈希表的key全部打出来，假设N:M，那么N需要打印M次。

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
}

计数排序的时间复杂度为（n+max）