js实现,归并排序,快速排序;插入排序,选择排序,冒泡排序

Posted 土匪7

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了js实现,归并排序,快速排序;插入排序,选择排序,冒泡排序相关的知识,希望对你有一定的参考价值。

// 插入排序
const insertSort =(arr) => {
  //假设前面的元素有序,把后一个元素插入合适的位置
  for (var i = 1;i<arr.length;i++){
    var preIdx = i-1
    var currentVal = arr[i]
    while(preIdx >= 0 && arr[preIdx] > currentVal){
      arr[preIdx+1] = arr[preIdx] //向后搬移一位
      preIdx--
    }
    arr[preIdx +1] = currentVal //把val插入正确的位置
  }
  return arr
}


// 快速排序
const pubQuickSort = (arr) => {
  var result = quickSort(arr,0,arr.length-1)
  return result
}

const quickSort = (arr,left,right) => {
  if(left < right){
    var pos = right //基准点取末尾
    var middleIdx = partion(arr,pos,left,right)

    var rightM = middleIdx -1 < left ? left: middleIdx-1
    quickSort(arr,left,rightM)

    var leftM = middleIdx + 1 > right ? right : middleIdx +1
    quickSort(arr,leftM,right)
    return arr
  }
}

const partion = (arr,pos,left,right) => {
  var posVal = arr[pos]
  var startIdx = left

  for(var i = left;i<right;i++){ //插入排序用的while,快速排序用的for?
    if(arr[i] < posVal){
      swap(arr,i,startIdx) //把所有小的元素移动到左边
      startIdx++
    }
  }
  swap(arr,startIdx,pos)
  return startIdx
}

const swap = (arr,i,j) => {
  var temp = arr[i]
  arr[i] = arr[j]
  arr[j] = temp
}

// 归并排序
const mergeSort =(arr)=> {
  if(arr.length < 2){
    return arr
  }

  var middleIdx = Math.floor(arr.length /2)
  var leftArr = arr.slice(0,middleIdx)
  var rightArr = arr.slice(middleIdx)

  return abMerge(mergeSort(leftArr),mergeSort(rightArr))
}

const abMerge = (leftArr,rightArr) => {
  var temp = []
  var idxLeft = 0
  var idxRight = 0
  while (idxLeft < leftArr.length && idxRight < rightArr.length){
    var leftVal = leftArr[idxLeft]
    var rightVal = rightArr[idxRight]
    if(leftVal < rightVal){
      temp.push(leftVal)
      idxLeft++
    }else {
      temp.push(rightVal)
      idxRight++
    }
  }

  var last = null
  if(idxLeft == leftArr.length){
    last = rightArr.slice(idxRight)
  }else {
    last = leftArr.slice(idxLeft)
  }

  return temp.concat(last)
}

// 选择排序
const chooseSort =(arr) => {
  // 找出后面最小的元素,交换到前面  1:找出最小idx 2:交换到前面
  for(var i =0 ;i < arr.length;i++){
    var minIdx = i
    for(var j=i+1;j<arr.length;j++){
      if(arr[j] < arr[minIdx]){
        minIdx = j
      }
    }
    var temp = arr[i]
    arr[i] = arr[minIdx]
    arr[minIdx] = temp
  }
  return arr
}

// 冒泡排序
const bubleSort =(arr)=> { //比较相邻元素
  for(var i = 0; i < arr.length;i++){
    for(var j = 0;j < arr.length - 1- i;j++){
      if(arr[j] > arr[j+1]){
        var temp = arr[j]
        arr[j] = arr[j+1]
        arr[j+1] = temp
      }
    }
  }
  return arr

}

//---测试-----
const test = [4, 5, 6, 3, 2, 1]

// var result = insertSort(test)
// console.log(‘插入排序:‘,result)

// var result = pubQuickSort(test)
// console.log(‘快速排序:‘,result)

// var result = mergeSort(test)
// console.log(‘归并排序:‘,result)

// var result = chooseSort(test)
// console.log(‘选择排序:‘,result)

var result = bubleSort(test)
console.log(‘冒泡排序:‘,result)

 插入,归并排序用的for-while

以上是关于js实现,归并排序,快速排序;插入排序,选择排序,冒泡排序的主要内容,如果未能解决你的问题,请参考以下文章

js排序算法总结——冒泡,快速,选择,插入,希尔,归并

常见排序算法的实现(归并排序快速排序堆排序选择排序插入排序希尔排序)

js排序算法总结——冒泡,快速,选择,插入,希尔,归并(转载)

Python八大算法的实现,插入排序希尔排序冒泡排序快速排序直接选择排序堆排序归并排序基数排序。

九大排序算法及其实现- 插入.冒泡.选择.归并.快速.堆排序.计数.基数.桶排序

C# 各种内部排序方法的实现(直接插入排序希尔排序冒泡排序快速排序直接选择排序堆排序归并排序基数排序)