QuickSort with Javascript에 대한 Big O 질문

저는 QuickSort로 작업하고 있으며이 문제 에 대해 LeetCode에서이 두 가지 알고리즘을 테스트했습니다 . 두 알고리즘 모두 작동하지만 하나는 다른 알고리즘보다 훨씬 빠르며 그 이유를 이해할 수 없습니다.

이것은 LeetCode의 시간 제한을 초과합니다.

function quickSort(array) {
    quickSortHelper(array, 0, array.length - 1);
    return array;
}

function quickSortHelper(array, start, end) {
    // Edge case
    if(start >= end) return;
    // Always choose the pivot index at the beginning of the array.
    const pivot = start;
    // The left index is next to the pivot on the right.
    let left = start + 1;
    let right = end;

    while (right >= left) {
        if (array[left] > array[right] && array[right] < array[pivot])
            swap(left, right, array);
        if (array[left] < array[pivot]) left += 1;
        if (array[right] > array[pivot]) right -= 1;
    }

    swap(pivot, right, array);

    // Always sort the smaller sub-array first
    const leftIsSmaller = right - 1 - start < end - (right + 1);

    if (leftIsSmaller) {
        quickSort(array, start, right - 1);
        quickSort(array, right + 1, end);
    }
    else {
        quickSort(array, right + 1, end);
        quickSort(array, start, right - 1);
    }
}

function swap(a, b, array) {
    [array[a], array[b]] = [array[b], array[a]];
    return array;
}

빅 O :

• 최악 : 시간 = O (n ^ 2) 왜냐하면 피벗이 정렬되지 않은 부분의 끝으로 계속 바뀌면 O (n-1) ~ O (n) 매번 = O (n * n)
• 최상 : 시간 = O (nlog (n)) 피벗이 어레이를 2 개로 분할 할 때.
• 평균 : 시간 = O (nlog (n))
• Space = O (log (n)) 2 개의 하위 배열이있는 재귀와 더 작은 하위 배열에 대해 먼저 빠른 정렬이 이루어지기 때문입니다.

이것은 LeetCode 시간 제한을 초과하지 않으며 대부분의 제출물보다 훨씬 빠릅니다. 큰 while 루프 안에있는 2 개의 while 루프는 (나에게) 느리게 보이지만 실제로는 더 빠릅니다.

function quickSort(array) {
    sortHelper(array, 0, array.length - 1);
    return array;
}

function sortHelper(array, start, end) {
    if (start >= end) return;
    let i = start;
    let j = end;
    let base = array[i];

    while (i < j) {
        while (i < j && array[j] >= base) j -= 1; // This makes sense but why this while loop has to happen before the other while loop?
        array[i] = array[j]; // this line
        while (i < j && array[i] <= base) i += 1;
        array[j] = array[i]; // and this line. don't they make you lose access to the values in the array?
    }
    array[i] = base;
    sortHelper(array, start, i - 1);
    sortHelper(array, i + 1, end);
}

왜 그런 겁니까?