- Pivot
- Partitioning
- Recursion
- Concatenation

The following items are the key points to remember when implementing a quick sort algorithm.

The basic premise is that we are going to continue to recursively split or **partition** an array until we have sorted partitions at which point we will join them back together created our sorted array.

Our **pivot** value is the value in the array that we are comparing against to determine what goes into our 2 partitions...or our **left** and **right **partitions.

```
var arr = [100, 33, 2, 53, 4, 89, 9, 9];
var pivot = arr[0]; //simple
//OR
var pivot = arr.length / 2; //efficient
```

Every time we split our array into two sections:

- Left - Values
**less than**the pivot - Right - Values
**greater than or equal**to the pivot

```
var arr = [10, 3, 2, 53, 4, 89, 9, 9];
var pivot = arr[0]; //10
//After first split we have 2 partitions
var left = [3, 2, 4, 9, 9];
var right = [53, 89];
//NOTE: pivot is still 10 and not on left/right.
```

Now that we have two partitions, we recursively pass them into the same function to continue to find our new **pivot** and **left** and **right** partitions.

```
var arr = [10, 3, 2, 34, 4, 53];
var pivot = arr[0]; //10
//After first split we have 2 partitions
var left = [3, 2, 4];
quickSort(left); //pivot = 3, left = [3, 2, 4], right = []
var right = [34, 53];
quickSort(right); //pivot = 34, left = [], right = [53]
```

NOTE: Our pivot is not added to our right partition but concatenated to the output of sorting the right partition.

On every iteration of our quicksort recursion we know that our pivot is greater than all values to the left and less than or equal to the first value on the right.

```
var arr = [10, 3, 2, 53, 34, 5];
left = [3, 2, 5], pivot = 10, right = [53, 34]
left = [2], pivot = 3, right = [5] left = [34], pivot = 53, right = []
left.concat(pivot, right); //[2,3,5] left.concat(pivot, right); //[34, 53]
[2, 3, 5].concat(pivot, [34, 53);
```

Therefore after our recursive function returns the sorted right partition, we simply **concatenate** the left partition, the pivot and the right partition.

- Pick an element, called a
*pivot*, from the array. - Reorder the array so that all elements with values less than the pivot come before the pivot, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the
*partition*operation. - Recursively apply the above steps to the sub-array of elements with smaller values and separately to the sub-array of elements with greater values.

The base case of the recursion is arrays of size zero or one, which never need to be sorted.