js 常用排序 快速排序 冒泡排序 选择排序 插入排序

快速排序1

递归调用，双指针方法

const quickSort = (array) => {
 const sort = (arr, left = 0, right = arr.length - 1) => {
  if (left >= right) {//如果左边的索引大于等于右边的索引说明整理完毕
   return
  }
 let i = left
 let j = right
 const baseVal = arr[j] // 取无序数组最后一个数为基准值
 while (i < j) {//把所有比基准值小的数放在左边大的数放在右边
  while (i < j && arr[i] <= baseVal) { //找到一个比基准值大的数交换
   i++
  }
  arr[j] = arr[i] // 将较大的值放在右边如果没有比基准值大的数就是将自己赋值给自己（i 等于 j）
  while (j > i && arr[j] >= baseVal) { //找到一个比基准值小的数交换
   j--
 }
  arr[i] = arr[j] // 将较小的值放在左边如果没有找到比基准值小的数就是将自己赋值给自己（i 等于 j）
 }
 arr[j] = baseVal // 将基准值放至中央位置完成一次循环（这时候 j 等于 i ）
 sort(arr, left, j-1) // 将左边的无序数组重复上面的操作
 sort(arr, j+1, right) // 将右边的无序数组重复上面的操作
 }
 const newArr = array.concat() // 为了保证这个函数是纯函数拷贝一次数组
 sort(newArr)
 return newArr
}

快速排序2

递归调用，分区间后，对左右子区间分别调用quickSort函数

// https://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html
const quickSort = (array) => {
  const length = array.length
  if (length <= 1) {
    return array
  }

  const midIndex = Math.floor(length / 2) //找出中间索引
  const midValue = array.splice(midIndex, 1)[ 0 ] // 取出每个区间的中间值，后续concat补上
  let leftArray = []
  let rightArray = []
  let index = 0

  while (index < length - 1) {
    const curValue = array[ index ]
    curValue <= midValue ? leftArray.push(curValue) : rightArray.push(curValue)
    index++
  }
  return quickSort(leftArray).concat([ midValue ], quickSort(rightArray))
}
const arr = [ -10, 10, 1, 34, 5, 1 ]
console.log(quickSort(arr))

冒泡排序

1. 从第一个元素开始，比较相邻的两个元素，前者大就交换位置
2. 每次遍历结束，都能找到一个最大值
3. 如果还有没排序的元素继续1
4. 与选择排序的区别：冒泡从 j = 0出发， 选择从 j=i+1 出发

// https://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html
//定义一个交换数值的函数
const swap = (array, a, b) => [ array[ b ], array[ a ] ] = [ array[ a ], array[ b ] ]
const bubbleSort = (array) => {
  const length = array.length
  // 两层for
  for (let i = 0; i < length - 1; i++) {
  //从 j = 0 出发
    for (let j = 0; j < length - 1 - i; j++) {
      if (array[ j ] > array[ j + 1 ]) {
        swap(array, j, j + 1)
      }
    }
  }
  return array
}

console.log(bubbleSort([ -1, 10, 10, 2 ]))

选择排序

1. 取出未排序的第一个元素，遍历该元素之后的部分并进行比较。第一次就是取第一个元素
2. 如果有更小的就交换位置
3. 与冒泡排序的区别：冒泡从 j = 0 出发， 选择从 j=i+1 出发

const swap = (arr,i,j) => {
    [arr[i],arr[j]] = [arr[j],arr[i]]
}
const BubbleSort = (arr) => {
    const length = arr.length
    for (let i = 0; i < length; i++){
        let minIndex = i
        // 从 j=i+1 出发
        for (let j = i+1;j<length;j++){
            if (arr[j] < arr[minIndex]){
                minIndex = j
            }
        }
        if (minIndex !== i){
            swap(arr,minIndex,i)
        }
    }
    return arr
}
console.log(BubbleSort([ -1, 10, 10, 2 ]))

插入排序

1. 首先有一个有序的序列，可以认为第一个元素就是已排序的序列
2. 从未排序序列中取一个元素出来，往有序序列中找到合适的位置，如果该位置比元素大，则后移动, 否则继续往前找

const insertSort = (array) => {
  for (let i = 1, length = array.length; i < length; i++) {
    let j = i - 1
    const curValue = array[ i ]
    
    while (j >= 0 && array[ j ] > curValue) {
      array[ j + 1 ] = array[ j ]
      j--
    }
    
    array[ j + 1 ] = curValue
  }

  return array
}
console.log(insertSort([ -1, 10, 10, 2 ]))