Advanced sorting - fast sorting

Quick line up

var sortArray = function(nums) {
    //  Quick line up 
    return quickStart(nums,0,nums.length-1);
}
function quickStart(nums,left,right) {
    if(left<right) {
    let index = partition(nums,left,right);
    quickStart(nums,0,index);
    quickStart(nums,index+1,right);
    }
    return nums;
}
//  Partition ：  Speed pointer 
function partition(array,left,right) {
    let pvit = left;   //  Select the leftmost side as the reference value , Can be optimized ( The leftmost may always be a smaller number , Take this as the reference value , Cause the recursive tree to tilt to one side )
    let index = left+1;
    for(let i=index;i<=right;i++) { // i  Pointer to a value less than the reference value , The previous elements are greater than the reference value .index  Pointer to a value greater than the reference value 
        if(array[i]<array[pvit]) { 
            swap(array,index,i);
            index++;
        }
    }
    swap(array,pvit,index-1);
    return index-1;

}
//  Swap elements in an array 
function swap(array,i,j) {
    let temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}
//  Partition ： Dig a hole 
function partition2(array,left,right) {
    let pivot = array[left]; //  The left element acts as the first pit , It is also the reference value 
    while(left<right) {
        while(left<right&&array[right]>=pivot) { // stay right In the process of moving ,>right  Are greater than the reference value ,<left  Are less than the reference value ,=left  Greater than the reference value  
            right--;
        }
        if(left<right) array[left] = array[right];
        while(left<right&&array[left]<=pivot) { // stay left  In the process of moving ,<left  Are less than the reference value ,>right  Are greater than the reference value ,=right  Less than reference value  
            left++;
        }
        if(left<right) array[right] = array[left];
    }
    array[left] = pivot;                                    //  The two elements meet , The meeting point is also the pit , At this time, the pit level is greater than the reference value , The pit level is lower than the reference value before , Fill in the reference value of the pit position 
    return left;
}
//  Partition ： Double pointer 
function partition3(array,left,right) {
    let pivot  = array[left]; // The reference value is selected on the left 
    let low  = left;
    while(left<right) {
        while(left<right&&array[right]>=pivot) { //  The right pointer moves first ,i、j Meet on the left side of the dividing line ; Left pointer moves first ,i、j Meet on the right side of the dividing line 
            right--;
        }
        while(left<right&&array[left]<=pivot) {
            left++;
        }
        if(left>=right) break;
        swap(array,left,right);                           // i、j meet , That is, the array completes the partition , Just move the reference value to the dividing point 
    }
    swap(array,low,left);
    return left;
    
}
//  When the array is an ordered sequence , Since the reference value is selected on the left , Causes the recursive tree to tilt , The sorting algorithm degenerates into O(N^2). Optimize ： Randomly select a number as the reference value 
//  Optimize ：
function quickStart(nums,left,right) {
    if(left<right) {
     let pivot = Math.floor(Math.random()*(right-left+1))+left; // The random value is used as the reference value 
     swap(nums,left,pivot)         //  Just change the random value to the far left 
    let index = partition(nums,left,right);
    quickStart(nums,0,index);
    quickStart(nums,index+1,right);
    }
    return nums;
}

 1.  Further optimization ：  When the random value is the minimum or maximum value every time, it will also cause the recursive tree to tilt , At this time, the three number limit is adopted , The recursive tree can be completely avoided from being too tilted . see leetcode Official website .
 2.  The above are sorted from small to large , So how to modify the code in reverse order ？