Quicksort java

                                    // @see https://www.youtube.com/watch?v=es2T6KY45cA&vl=en
// @see https://www.youtube.com/watch?v=aXXWXz5rF64
// @see https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html

function partition(list, start, end) {
    const pivot = list[end];
    let i = start;
    for (let j = start; j < end; j += 1) {
        if (list[j] <= pivot) {
            [list[j], list[i]] = [list[i], list[j]];
            i++;
        }
    }
    [list[i], list[end]] = [list[end], list[i]];
    return i;
}

function quicksort(list, start = 0, end = undefined) {
    if (end === undefined) {
        end = list.length - 1;
    }
    if (start < end) {
        const p = partition(list, start, end);
        quicksort(list, start, p - 1);
        quicksort(list, p + 1, end);
    }
    return list;
}

quicksort([5, 4, 2, 6, 10, 8, 7, 1, 0]);

                                    //GOD's quicksort
public static <E extends Comparable<E>> List<E> sort(List<E> col) {
  if (col == null || col.isEmpty())
    return Collections.emptyList();
  else {
    E pivot = col.get(0);
    Map<Integer, List<E>> grouped = col.stream()
      .collect(Collectors.groupingBy(pivot::compareTo));
    return Stream.of(sort(grouped.get(1)), grouped.get(0), sort(grouped.get(-1)))
      .flatMap(Collection::stream).collect(Collectors.toList());
  }
}

                                    
import java.util.*;
class QuickSort {
    //selects last element as pivot, pi using which array is partitioned.
    int partition(int intArray[], int low, int high) {
        int pi = intArray[high];
        int i = (low-1); // smaller element index
        for (int j=low; j<high; j++) {
            // check if current element is less than or equal to pi
            if (intArray[j] <= pi) {
                i++;
                // swap intArray[i] and intArray[j]
                int temp = intArray[i];
                intArray[i] = intArray[j];
                intArray[j] = temp;
            }
        }

        // swap intArray[i+1] and intArray[high] (or pi)
        int temp = intArray[i+1];
        intArray[i+1] = intArray[high];
        intArray[high] = temp;

        return i+1;
    }


    //routine to sort the array partitions recursively
    void quick_sort(int intArray[], int low, int high) {
        if (low < high) {
            //partition the array around pi=>partitioning index and return pi
            int pi = partition(intArray, low, high);

            // sort each partition recursively
            quick_sort(intArray, low, pi-1);
            quick_sort(intArray, pi+1, high);
        }
    }
}

class QUICK_SORT{
    public static void main(String args[]) {
        //initialize a numeric array, intArray
        int intArray[] = {3,2,1,6,5,4};
        int n = intArray.length;
        //print the original array
        System.out.println("Original Array: " + Arrays.toString(intArray));
        //call quick_sort routine using QuickSort object
        QuickSort obj = new QuickSort();
        obj.quick_sort(intArray, 0, n-1);
        //print the sorted array
        System.out.println("\nSorted Array: " + Arrays.toString(intArray));
    }
}

                                    public static ArrayList<Vehicle> quickSort(ArrayList<Vehicle> list)
{
    if (list.isEmpty()) 
        return list; // start with recursion base case
    ArrayList<Vehicle> sorted;  // this shall be the sorted list to return, no needd to initialise
    ArrayList<Vehicle> smaller = new ArrayList<Vehicle>(); // Vehicles smaller than pivot
    ArrayList<Vehicle> greater = new ArrayList<Vehicle>(); // Vehicles greater than pivot
    Vehicle pivot = list.get(0);  // first Vehicle in list, used as pivot
    int i;
    Vehicle j;     // Variable used for Vehicles in the loop
    for (i=1;i<list.size();i++)
    {
        j=list.get(i);
        if (j.compareTo(pivot)<0)   // make sure Vehicle has proper compareTo method 
            smaller.add(j);
        else
            greater.add(j);
    }
    smaller=quickSort(smaller);  // capitalise 's'
    greater=quickSort(greater);  // sort both halfs recursively
    smaller.add(pivot);          // add initial pivot to the end of the (now sorted) smaller Vehicles
    smaller.addAll(greater);     // add the (now sorted) greater Vehicles to the smaller ones (now smaller is essentially your sorted list)
    sorted = smaller;            // assign it to sorted; one could just as well do: return smaller

    return sorted;
}

                                    	//Worst case: if pivot was at the end and all numbers are greater than the pivot
	//Best case: (n log n): due to you cutting the array in half n times
	// Average case(n log n): ^

public class QuickSort {
	
	public static void main(String [] args) {
		int [] arr = {5, 1, 6, 4, 2, 3};
		quickSort(arr, 0, arr.length);
		
      	/*Using a for each loop to print out the ordered numbers from the array*/
      	for(int i: arr){
        	System.out.println(i);
        }// End of the for-each loop
	
	}// End of the main method
	
	public static void quickSort(int [] arr, int start, int end) {
		/*Base case*/
		if(start >= end) {
			return;
		}// End of the base case
		
		int pIndex = partition(arr, start, end);// The index of the pivot.
		//System.out.println(pIndex);
		
		/*Recursive cases*/
		quickSort(arr, start, pIndex - 1);// Left side of the array
		quickSort(arr, pIndex + 1, end);// Right side of the array
		
	}// End of the quicksort method
	
	public static int partition(int [] arr, int start, int end) {
		int pivot = arr[end - 1];// Select the pivot to be the last element
		int pIndex = start;// (Partition index) Indicates where the pivot will be. 
		
		for(int i = start; i < end; i++) {
			if(arr[i] < pivot) {
				
				// if a number is smaller than the pivot, it gets swapped with the Partition index
				int temp = arr[pIndex];
				arr[pIndex] = arr[i];
				arr[i] = temp;
				
				pIndex++;// increments the partition index, only stops when pivot is in the right area
			}// End of the if statement
			
		}// End of the for loop
		
		// This swaps the pivot with the element that stopped where the pivot should be
		arr[end - 1] = arr[pIndex];
		arr[pIndex] = pivot;
		return pIndex;
	}// End of the partition method
	
}// End of the QuickSort class