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 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