基础排序、二分查找汇总

标签：排序算法   alt   用两个   算法复杂度   交换   math   rom   常见   hal   

一、常见排序算法复杂度和稳定性

二、js代码实现和思路

（1）冒泡排序：从数组起始位置两两比较，前一个大于后一个就交换位置，第一轮比较后最大的那个数就排到了最后，循环比较数组长度-1次

function bubble (arr) {
  for (let j = 0; j < arr.length - 1; j++) {
    for (let i = 0; i < arr.length - 1 - j; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]]
      }
    }
  }
  return arr
}

（2）选择排序：依次找出数组中最小，第二小...的数，放在arr[0],arr[1],...的位置

function selectSotr(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[j] < arr[i]) {
        [arr[i], arr[j]] = [arr[j], arr[i]]
      }
    }
  }
  return arr
}

（3）插入排序：类比打扑克牌，开辟一个新的数组就好比左手已整理的牌，右手取牌将其插入合适位置

function insert (arr) {

  let arr1 = []

  arr1.push(arr[0])

  for (let i = 1; i < arr.length; i++) {

    for (let j = arr1.length - 1; j >= 0; j--) {

      if (arr[i] > arr1[j]) {

        arr1.splice(j + 1, 0, arr[i])

        break

      }

      if (arr1[0] > arr[i]) {

        arr1.unshift(arr[i])

      }

    }

  }

  return arr1

}

（4）快速排序：选取一个基准点，使用两个数组分别放入比基准点小和比基准点大的项，递归 （数组原本有序或者完全倒序时快排效率最低）

function quickSort (arr) {

  let len = arr.length

  if (len < 2) return arr

  let flag = arr[0]

  let left = []

  let right = []

  for (let i = 1; i < len; i++) {

    if (arr[i] < flag) {

      left.push(arr[i])

    } else {

      right.push(arr[i])

    }

  }

  return quickSort(left).concat(flag, quickSort(right))

}

 （5）二分查找：顾名思义先选取数组中间位置和要查找项比较，每次查找范围减半

function half (arr, item) {
  let begin = 0
  let end = arr.length

  while (begin <= end) {
    let mid = Math.floor((begin + end) / 2)
    if (arr[mid] > item) {
      end = mid - 1
    } else if (arr[mid] < item) {
      begin = mid + 1
    } else {
      return mid
    }
  }
  return -1
}

基础排序、二分查找汇总

标签：排序算法   alt   用两个   算法复杂度   交换   math   rom   常见   hal   

原文地址：https://www.cnblogs.com/ccj9697/p/11302258.html