JS版六大排序算法

测试数组与全局变量

let arr = [100,3,5,38,15,36,3,26,37,19,50,48,46,47,1]
let len = arr.length

冒泡排序

function bubbleSort(arr){
  // 十个数只需要外层九次循环就够了
  for(let i = 0; i < len-1; i++){
    for(let j = 0; j < len-1-i; j++){
      if(arr[j]>arr[j+1]){
        let temp = arr[j]
        arr[j] = arr[j+1]
        arr[j+1] = temp
      }
    }
  }
  return arr
}

选择排序

function selectSort(arr){
  for(let i = 0; i < len-1; i++){
    let minIndex = i
    for(let j = i+1; j < len; j++){
      if(arr[minIndex]>arr[j]){
        minIndex = j
      }
    }
    let temp = arr[i]
    arr[i] = arr[minIndex]
    arr[minIndex] = temp
  }
  return arr
}

插入排序

function insertSort(arr){
  for(let i = 0; i < len-1; i++){
    let temp = arr[i+1]
    for(var j = i; j >= 0 && temp < arr[j]; j--){
      arr[j+1] = arr[j]
    }
    // temp > arr[j]时不符合条件跳出循环，此时j--已经执行，此时j+1相当于i了
    arr[j+1] = temp
  }
  return arr
}

// 插入排序(while循环)
function insertMoreSort(arr){
  for(let i = 0; i < len-1; i++){
    let temp = arr[i+1]
    let j = i
    while(j >= 0 && temp < arr[j]){
      arr[j+1] = arr[j]
      j--
    }
    arr[j+1] = temp
  }
  return arr
}

希尔排序 （其实是优化版插入排序，设置间隔值去排序）

function shellSort(arr){
  // 确定外层大循环，长度为14的数组分组间隔分别为7，3，1
  for(let gap = parseInt(len/2); gap > 0; gap = parseInt(gap/2)){
    // 从前面顺序挨个数与gap间距后的数进行比较
    for(let i = 0; i + gap < len; i++){
      // 到这里已经几乎完成了希尔排序分组的思想，接下来其实就是插入排序
      let temp = arr[i+gap]
      for(var j = i; j >= 0 && arr[j] > temp; j -= gap){
        arr[j+gap] = arr[j]
      }
      arr[j+gap] = temp
    }
  }
  return arr
}

mergeSort(归并排序)（递归分组对比排序）

function mergeSort(arr){
  // 最小单位为1个数
  if(arr.length < 2){
    return arr
  }
  let half = parseInt(arr.length/2)
  let leftArr = arr.slice(0, half)
  let rightArr = arr.slice(half)
  // 返回一个排好序的数组(那左边部分跟右边部分排序)
  return compare(mergeSort(leftArr), mergeSort(rightArr))
}

// 递归的排序函数

function compare(left, right) {
  let arr = []
  while(left.length && right.length){
    if(left[0] < right[0]){
      arr.push(left.shift())
    } else {
      arr.push(right.shift())
    }
  }
  // 一定会有一个数组是空的，另一个数组一个一个push进去就行，或者concat连接
  while(left.length){
    arr.push(left.shift())
  }
  while(right.length){
    arr.push(right.shift())
  }
  return arr
}

快速排序（在网上看了挺多，写了两种不一样的）
第一种

function quickSort(arr, left, right){
  if(left >= right) return;
  // 交换函数的返回值是一个特殊位置，左边的都比它小，右边的都比它大，以此为界两边分别再进行排序
  let special = quickAssist(arr, left, right)
  // 对左右分别再次排序
  quickSort(arr, left, special-1)
  quickSort(arr, special+1, right)

  return arr
}

递归的排序函数

function quickAssist(arr, left, right){
  // 设置基准值为第一个
  let basic = left
  // 从下一个开始排序
  let index = basic + 1
  for(var i = index; i <= right; i++){
    if(arr[i] < arr[basic]){
      // 所有比基准值大的数调整位置
      let temp = arr[i]
      arr[i] = arr[index]
      arr[index] = temp
      index++
    }
  }
  // 调整基准值的位置
  let temp = arr[basic]
  arr[basic] = arr[index-1]
  arr[index-1] = temp
  // 返回特殊值
  return --index
}

第二种

function quickSortTwo(arr, left, right){
  if(left >= right) return ; // 设置退出条件，当数组中只有一个元素时退出
  let basic = arr[left]  //设置基准数为第一个元素
  // 不能在原来的left,right基础上进行操作
  let i = left
  let j = right
  while(i < j){
    // 从右往左找一个比标准值小的或者一样的（把小的数尽可能往前调整）
    while( i < j && arr[j] > basic){
      j--
    }
    // 从左往右找一个比标准值大的（如果和标准值一样，不能向后调整）
    while( i < j && arr[i] <= basic ){
      i++
    }
    // 找到符合条件得两个元素的位置且两个哨兵没有相遇就交换双方的值
    if(i < j){
      let temp = arr[i]
      arr[i] = arr[j]
      arr[j] = temp
    }
  }
  // 交换基准值与两个哨兵相遇位置的值
  arr[left] = arr[i]
  arr[i] = basic
  // 将基准值左边的与右边重新递归排序
  quickSortTwo(arr, left, i-1)
  quickSortTwo(arr, i+1, right)
  return arr
}

如有不对，多多指教