What I am missing in Quick Sort Algorithm - algorithm

Question

I am trying to make quicksort algorithm by selecting first item as pivot always in partition function and return the index of that pivot item to use in quickSort function...
I do not have any idea why I am facing that error
function partition(items, left, right) {
^ RangeError: Maximum call stack size exceeded
The whole code is as below
var items = [5, 3, 6, 7, 2, 9];
function swap(items, leftIndex, rightIndex) {
var temp = items[leftIndex];
items[leftIndex] = items[rightIndex];
items[rightIndex] = temp;
}
function partition(items, left, right) {
var pivot = items[0];
i = left;
j = right;
while (i < j) {
do {
i++;
} while (items[i] <= pivot);
do {
j--;
} while (items[j] > pivot);
if (i < j) {
swap(items, i, j);
}
}
swap(items, 0, j);
return j;
}
function quickSort(items, left, right) {
var index;
if (items.length > 1) {
index = partition(items, left, right); //index returned from partition
if (left < index - 1) {
//more elements on the left side of the pivot
quickSort(items, left, index - 1);
}
if (index < right) {
//more elements on the right side of the pivot
quickSort(items, index, right);
}
}
return items;
}
var sortedArray = quickSort(items, 0, items.length - 1);
//console.log(sortedArray); / / expected[(2, 3, 5, 6, 7, 9)];

Answer 1

If partition(items, left, right) is meant to take the whole array (items) and the indices of its left and right ends, then I believe the pivot should not be items[0] but rather items[left]. Similarly, at the end, it should be swap(items, left, j).
However, notice what happens if the array in partition has its smallest element as its first element, say [5, 7, 6, 9]. Then 5 will be the pivot, i will land on 7, j will land on 5, and j = left will be returned, at which point in quickSort you will have index = left, and then you will execute quickSort(items, index, right) which is quickSort(items, left, right), resulting in infinite recursion. You should thus execute quickSort(items, index + 1, right), since the pivot is already on it srightful place and shouldn't be further moved.
After these changes, the code looks like this:
var items = [5, 3, 6, 7, 2, 9];
function swap(items, leftIndex, rightIndex) {
var temp = items[leftIndex];
items[leftIndex] = items[rightIndex];
items[rightIndex] = temp;
}
function partition(items, left, right) {
var pivot = items[left];
console.log("partition: " + items + " " + left + " " + right);
i = left;
j = right;
while (i < j) {
do {
i++;
} while (items[i] <= pivot);
do {
j--;
} while (items[j] > pivot);
if (i < j) {
swap(items, i, j);
}
}
swap(items, left, j);
return j;
}
function quickSort(items, left, right) {
console.log("quickSort: " + items + " " + left + " " + right);
var index;
if (right - left > 1) {
index = partition(items, left, right); //index returned from partition
if (left < index - 1) {
//more elements on the left side of the pivot
quickSort(items, left, index - 1);
}
if (index + 1 < right) {
//more elements on the right side of the pivot
quickSort(items, index + 1, right);
}
}
return items;
}
var sortedArray = quickSort(items, 0, items.length - 1);
// returns [2,3,5,7,6,9]
This means there is an error in partition, and I'll leave that to you. Perhaps the wikipedia or G4G websites will help you to write a correct partition algorithm. (Hint: it's related to the fact that i and j pass each other in partition, causing the original problem.
BUT This is not the end!
You can arrive at the same error, if you choose the first element as your pivot every single time. Imagine, that the array is already sorted, so let's say the input is [1, 2, 3, 4, 5]. Then in the first call of quickSort, you will partition the array into 1 and [2, 3, 4, 5]. Then, you will call the function recursively on the right array, partitioning it into 2 and [3, 4, 5] and so on.
This means, if your array is big (say, it has 1 million elements), then you will have a very large stack size (at least two million function calls, a million partitions and a million quickSorts). This is due to the unfortunate pivot selection.
To solve this problem, you should randomize the pivot. That way, the chance that your stack size will be larger than logarithmic is incredibly small (basically zero), and the problem is effortlessly solved.