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)