基础排序算法

排序算法

冒泡排序

// 冒泡排序
// 1.外层循环-1
// 2.外层循环-1又-i  (使用内层循环比较)
// 3.内循环相邻的两个比较大小
// 4.交换值的位置  (大于升序,小于降序)
function bubbleSort(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        let step = arr[j]
        arr[j] = arr[j + 1]
        arr[j + 1] = step
      }
    }
  }
  return arr
}

选择排序

// 选择排序  select
function selectSort(array) {
  for (let i = 0; i < array.length - 1; i++) {
    let maxindex = i //选择一个最大的下标
    for (let j = i + 1; j < array.length; j++) {
      // 不包含自己,所以 j=i+1 
      if (array[j] > array[maxindex]) {
        // 后续下标的值大于选择的下标值
        maxindex = j
      }
    }
    if (i != maxindex) {
      // 最大值的下标不是我所选择的下标
      // 交换位置
      let temp = array[i]
      array[i] = array[maxindex]
      array[maxindex] = temp
    }
  }
  return array
}

快排,冒泡升级,使用递归

/ 快速排序 quickSort 无限二分
function quickSort(array) {
  // 判断数值长度是否大于1 ,如果不是,直接返回
  if (array.length <= 1) {
    return array
  }
  // 根据数组长度/2,向下取整,获得中间数的下标
  let centerIndex = Math.round(array.length / 2)
  // 根据下标,取出中间数的值
  let centerVal = array.splice(centerIndex, 1)[0]
  // 准备两个空字符串
  let left = [], right = []
  // 数组遍历
  for (let index = 0; index < array.length; index++) {
    // 判断数组中的数与中间值的大小 
    if (array[index] > centerVal) {
      // 大于中间数的放右边
      right.push(array[index])
    } else {
      // 小于放左边
      left.push(array[index])
    }
  } 
   // 利用递归,继续二分
   // 最后返回拼接后的数组
  return quickSort(left).concat(centerVal, quickSort(right))
}