常见排序算法一句话简记

1. 冒泡 两层循环相邻对比交换

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
                var temp = arr[j+1];        // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

2. 选择排序 每次从剩余长度中挑出一个最大的（或最小的）和前面的值交换

let minIndex=(numbers)=>{
   let index=0;
  for(let i=0;i<numbers.length;i++){
     if(numbers[i]<numbers[index]){
       index=i
     }
  }
  return index
}
let swap=(numbers,minIndex,index)=>{
  let temp=numbers[minIndex]
  numbers[minIndex]=numbers[index]
  numbers[index]=temp
}
let sort=numbers=>{
   for(let i=0;i<numbers.length;i++){
     let index=minIndex(numbers.slice(i))+i
     if(index!==i){
       swap(numbers,index,i)
     }
   
   }
  return numbers
}

3. 快速排序 用递归，确立一个中间值和一左一右两个数组，如果从小到大排，小于中间值的放左边，大于中间值的放右边，再合起来

//阮一峰老师写法
let quickSort=(numbers)=>{
if(numbers.length<=1){
  return numbers
}
  let left=[]
  let right=[]
  let pivotIndex=Math.floor(numbers.length/2)
  let pivot=numbers.splice(pivotIndex,1)[0]
for(let i=0;i<numbers.length;i++){
  if(numbers[i]<pivot){
    left.push(numbers[i])
  }else{
    right.push(numbers[i])
  }
}
  return quickSort(left).concat([pivot],quickSort(right))
}

let xxx=[324,453,457,3245,654,6456,66]
xxx=quickSort(xxx)
console.log(xxx)

4. 插入排序 从头开始遍历，每次取出的值都与先前的逐一比对，插入到合适的位置

function insertionSort(arr) {
    var len = arr.length;
    var preIndex, current;
    for (var i = 1; i < len; i++) {
        preIndex = i - 1;
        current = arr[i];
        while(preIndex >= 0 && arr[preIndex] > current) {
            arr[preIndex+1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex+1] = current;
    }
    return arr;
}

5. 归并排序 一半一半的分割，把数组分割成单独的每一项，再两两比较，每次取大的（或者小的）结合起来

let mergeSort=(numbers)=>{
  let n= numbers.length
  if(n===1){return numbers}
  let left=numbers.slice(0,Math.floor(n/2))
  let right=numbers.slice(Math.floor(n/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))
}

6. 计数排序 类似排列扑克牌，相同的放到一起，用一个hash表记录“某项：数量”的键值对，记录数值最大的那一项，以最大的那一项为for循环的终点，从大到小（或从小到大）拿出hash中的每一项排好即可

let countSort=numbers=>{
  let hashTable={},max=0,result=[]
  for(let i=0;i<numbers.length;i++){
    if(!(numbers[i] in hashTable)){
      hashTable[numbers[i]]=1
    }else{
      hashTable[numbers[i]]+=1
    }
    if(numbers[i]>max){max=numbers[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
}

部分参考