# Is there something wrong with this quicksort implementation that uses a random pivot?

``````  const swap = (arr, i, j) => {
const temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
};

const partition = (arr, left, right) => {
const pivot = arr[Math.floor(Math.random() * (arr.length - left) + left)];
while (left <= right) {
while (arr[left] < pivot) {
left++;
}
while (arr[right] > pivot) {
right--;
}
if (left <= right) {
swap(arr, left, right);
left++;
right--;
}
}
return left;
};

const quickSort = (arr, left, right) => {
if (left === undefined) {
left = 0;
right = arr.length - 1;
}
if (left >= right) {
return arr;
}
const pIndex = partition(arr, left, right);
quickSort(arr, left, pIndex - 1);
quickSort(arr, pIndex, right);
return arr;
};
``````

I’m always getting the right results, but I used a tool to check the time it takes to run, and it varies drastically for large inputs. I imagine it has to do with the random pivot, but I’m still not convinced that’s it. I’m kind of new to sorting algorithms and I’ve been analyzing the code in a debugger for awhile, but I’m not sure that there isn’t a mistake or inaccuracy somewhere. I’d appreciate if someone can look it over and verify whether or not this algorithm is implemented correctly. Let’s assume for now that I want to maintain the random pivot over picking the middle element, or some other way.

### >Solution :

Yes, your choice of the pivot is broken. You’re choosing an element anywhere from `left` to the end of the array, not an element between `left` and `right`.