直接使用给定规则的sort()

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 将给定数组排序
 * @param arr int整型一维数组 待排序的数组
 * @return int整型一维数组
 */
function MySort( arr ) {
    // write code here
    return arr.sort((a,b)=>{
        return a-b
    })
}
module.exports = {
    MySort : MySort
};

七行手撕快排

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 将给定数组排序
 * @param arr int整型一维数组 待排序的数组
 * @return int整型一维数组
 */
function MySort( arr ) {
    // write code here
    if(arr.length<=1) return arr;
    const current=arr.splice(arr.length/2,1)[0]//这里是拿出一个基准，arr.length-1也可以,注意，splice在原数组中删除这个元素
    let left=[],right=[]
    arr.forEach(ele=>{
        (ele>current?right:left).push(ele)
    })
    return MySort(left).concat(current,MySort(right))
}
module.exports = {
    MySort : MySort
};

正常手撕快排

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 * 将给定数组排序
 * @param arr int整型一维数组 待排序的数组
 * @return int整型一维数组
 */
function MySort( arr ) {
    // write code here
    return quick(arr,0,arr.length-1)
}
function quick(arr,left,right){
    let index
    if(arr.length>1){
        index=partition(arr,left,right)
        if(left<index-1){
            quick(arr,left,index-1)
        }
        if(index<right){
            quick(arr,index,right)
        }
    }
    return arr
}
function partition(arr,left,right){
    const pivot=arr[left]
    let i=left,j=right
    while(i<=j){
        while(arr[i]<pivot){
            i++
        }
        while(arr[j]>pivot){
            j--
        }
        if(i<=j){
            [arr[i],arr[j]]=[arr[j],arr[i]]
            i++
            j--
        }
    }
    return i
}
module.exports = {
    MySort : MySort
};