排序算法 | JS

1、冒泡排序

function bubbleSort(arr,order){
    let len = arr.length-1,flag=true
    for(let i=0;(i<len)&&flag;i++){
        flag=false
        for(let j=0;j<len-i;j++){
            if((arr[j]-arr[j+1])*order>0){
                flag=true
                let tran = arr[j]
                arr[j]=arr[j+1]
                arr[j+1]=tran
            }
        }
    }
}
let arr=[2,3,0,5,1,6,8,4]
bubbleSort(arr,1)
console.log(arr)

2、插入排序

function insertSort(arr){
    let len=arr.length-1
    for(let i=1;i<len;i++){
        let currrent=arr[i],j
        for(j=i-1;j>=0&&arr[j]>currrent;j--){
            arr[j+1]=arr[j]
        }
        arr[j+1]=currrent
    }
}
let arr=[2,3,0,5,1,6,-6,4]
insertSort(arr)
console.log(arr)

3、快速排序

function quickSort(arr,low,high){
  if(low>high) return
  let mid=partition(arr,low,high)
  quickSort(arr,low,mid-1)
  quickSort(arr,mid+1,high)
}
function partition(arr,low,high){
    for(i=low,j=low;j<high;j++){
        if(arr[j]<arr[high]){
            swap(arr,i++,j)
        }
    }
    swap(arr,i,j)
    return i
}
function swap(arr,i,j){
    let tran=arr[i]
    arr[i]=arr[j]
    arr[j]=tran
}
let arr=[2,3,0,5,1,6,8,4]
quickSort(arr,0,arr.length-1)
console.log(arr)

4、归并排序

function mergeSort(arr,low,high){
    if(low>=high) return
    let mid = Math.floor((low+high)/2)
    mergeSort(arr,low,mid)
    mergeSort(arr,mid+1,high)
    merge(arr,low,mid,high)
}
function merge(arr,low,mid,high){
    let k=low,i=low,j=mid+1
    let copy=[...arr]
    while(k<=high){
        if(i>mid){
            arr[k++]=copy[j++]
        }else if(j>high){
            arr[k++]=copy[i++]
        }else if(copy[i]>copy[j]){
            arr[k++]=copy[j++]
        }else {
            arr[k++]=copy[i++]
        } 
    }
}
let arr=[2,3,0,5,1,6,8,4]
mergeSort(arr,0,arr.length-1)
console.log(arr)

5、堆排序

function heapify(arr,i,high){
    if(i>=high) return
    let left=2*i+1
    let right =2*i+2
    let max=i
    if((left<high)&&(arr[max]<arr[left])) max =left
    if((right<high)&&(arr[max]<arr[right])) max =right
    if(i!=max){
      swap(arr,i,max)
      heapify(arr,max,high)
    }
}
function buildHeap(arr){
  let high = arr.length
  for(let m=Math.floor(high/2);m>=0;m--){
    heapify(arr,m,high)
  }
}
function heapSort(arr){
    buildHeap(arr)
    let high=arr.length
    let j=high-1
    for(let i=0;i<high;i++){
        swap(arr,0,j)
        heapify(arr,0,j--)
    }
}
function swap(arr,i,j){
    let tran = arr[i]
    arr[i]= arr[j]
    arr[j]= tran
}
arr=[2,-1,7,6,5,12]
heapSort(arr)
console.log(arr)

6、原生排序

function sort(arr,order){
    arr.sort((a,b)=>{
        return (a-b)*order
    })
}
let arr=[2,3,0,5,1,6,8,4]
sort(arr,-1)
console.log(arr)

不同条件下，排序方法的选择

(1)若n较小(如n≤50)，可采用直接插入或直接选择排序。
    当记录规模较小时，直接插入排序较好；否则因为直接选择移动的记录数少于直接插人，应选直接选择排序为宜。
(2)若文件初始状态基本有序(指正序)，则应选用直接插人、冒泡或随机的快速排序为宜；
(3)若n较大，则应采用时间复杂度为O(nlgn)的排序方法：快速排序、堆排序或归并排序。
    快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
    堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的。
    若要求排序稳定，则可选用归并排序。但本章介绍的从单个记录起进行两两归并的  排序算法并不值得提倡，通常可以将它和直接插入排序结合在一起使用。先利用直接插入排序求得较长的有序子文件，         然后再两两归并之。因为直接插入排序是稳定 的，所以改进后的归并排序仍是稳定的。

 参考：

《算法设计指南》，Skiena

https://kaiwu.lagou.com/course/courseInfo.htm?courseId=3#/detail/pc?id=31

堆排序：https://www.bilibili.com/video/BV1Eb41147dK?from=search&seid=5680730895913351029