//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());

  }

}

/*

    This is an implementation of the quick sort algorithm.

​

    Let n be the size of the list to sort

    Best: O(nlog2(n)) time | O(log2(n)) space

    Average: O(nlog2(n)) time | O(log2(n)) space

    Worst: O(n^2) time | O(log2(n)) space

*/

import java.util.Arrays;

​

public class QuickSort {

    public static void main(String[] args) {

        int[] arr = { 1, 10, 5, 3, 6 };

        quickSort(arr);

        // Below prints: [1, 3, 5, 6, 10]

        System.out.println(Arrays.toString(arr));

    }

​

    public static void quickSort(int[] array) {

        // Sort array recursively

        quickSortUtil(array, 0, array.length - 1);

    }

​

    private static void quickSortUtil(int[] array, int startIdx, int endIdx) {

        // Base case: at this point array is sorted

        if (startIdx >= endIdx) {

            return;

        }

        // Let first value be pivot

        // Sort every other number wrt to pivot

        int pivotIdx = startIdx;

        int leftIdx = startIdx + 1;

        int rightIdx = endIdx;

        // Make sure that element at leftIdx <= to one at pivotIdx

        // and element at rightIdx is >= to one at pivotIdx

        while (leftIdx <= rightIdx) {

            if (array[leftIdx] > array[pivotIdx] && array[rightIdx] < array[pivotIdx]) {

                swap(leftIdx, rightIdx, array);

            }

            if (array[leftIdx] <= array[pivotIdx]) {

                leftIdx++;

            }

            if (array[rightIdx] >= array[pivotIdx]) {

                rightIdx--;

            }

        }

​

        swap(pivotIdx, rightIdx, array);

        // At the end of current iteration, element at

        // pivot is in its final sorted position

        quickSortUtil(array, startIdx, rightIdx - 1);

        quickSortUtil(array, rightIdx + 1, endIdx);

    }

​

    private static void swap(int i, int j, int[] array) {

        int temp = array[i];

        array[i] = array[j];

        array[j] = temp;

    }

}

​

import java.util.Arrays;

//so fun to run//try it (;

//Illustrate array in size of 100 Million Integers 

//global arrays only!!

public class Quick {

    static int[] arr = new int[10000000];

    public static void main(String[] args) {//only use with global array!

        for(int i=0; i<arr.length;i++){

            arr[i]= (int)(Math.random()*1000);

        }

        quickSort(0, arr.length-1, arr[arr.length-1]);

       //(send 0 to lowi,

      //send the last index in the array to higi, 

      //send to pivot the last value in the array)

       System.out.println(Arrays.toString(arr));

    }

    public static void quickSort(int lowi,int higi,int pivot){

        if(higi<=lowi)

          return;

        if(higi - lowi <1)

           return;

        if(higi - lowi == 1){

            if(arr[lowi]>arr[higi])

               swap(lowi, higi);

                 return;

        }

        int temp, next = arr[lowi];

        int higiS = higi, lowiS = lowi,pos = lowi;

        while(higi-lowi >= 1){

            if(next<pivot){

                 temp = arr[higi];

                 if(higi == higiS)

                   temp = arr[++pos];

                 else

                   temp = arr[higi];

                arr[higi--] = next; 

                }

            else{

                if(lowi<=pos)

                  temp = arr[++pos];

                else

                  temp = arr[lowi];

                arr[lowi++] = next;

                }

                next = temp;

            }

            if(lowi<pos)

              lowi = pos-1;

        arr[lowi] = pivot;

        quickSort(lowi+1, higiS, arr[higiS]);

        if(lowi-1>=0)

        quickSort(lowiS, lowi-1, arr[lowi-1]);

        return;

    }

    public static void swap(int fI,int sI){

        int temp = arr[fI];

        arr[fI] = arr[sI];

        arr[sI] = temp;

    }

}

​

// Java implementation of QuickSort

import java.io.*;

class GFG{

// A utility function to swap two elements

static void swap(int[] arr, int i, int j)

{

    int temp = arr[i];

    arr[i] = arr[j];

    arr[j] = temp;

}

/* This function takes last element as pivot, places

   the pivot element at its correct position in sorted

   array, and places all smaller (smaller than pivot)

   to left of pivot and all greater elements to right

   of pivot */

static int partition(int[] arr, int low, int high)

{

    // pivot

    int pivot = arr[high];

    // Index of smaller element and

    // indicates the right position

    // of pivot found so far

    int i = (low - 1);

    for(int j = low; j <= high - 1; j++)

    {

        // If current element is smaller

        // than the pivot

        if (arr[j] < pivot)

        {

            // Increment index of

            // smaller element

            i++;

            swap(arr, i, j);

        }

    }

    swap(arr, i + 1, high);

    return (i + 1);

}

/* The main function that implements QuickSort

          arr[] --> Array to be sorted,

          low --> Starting index,

          high --> Ending index

 */

static void quickSort(int[] arr, int low, int high)

{

    if (low < high)

    {

        // pi is partitioning index, arr[p]

        // is now at right place

        int pi = partition(arr, low, high);

        // Separately sort elements before

        // partition and after partition

        quickSort(arr, low, pi - 1);

        quickSort(arr, pi + 1, high);

    }

}

// Function to print an array

static void printArray(int[] arr, int size)

{

    for(int i = 0; i < size; i++)

        System.out.print(arr[i] + " ");

    System.out.println();

}

// Driver Code

public static void main(String[] args)

{

    int[] arr = { 10, 7, 8, 9, 1, 5 };

    int n = arr.length;

    quickSort(arr, 0, n - 1);

    System.out.println("Sorted array: ");

    printArray(arr, n);

}

}

// This code is contributed by Ayush Choudhary

import java.util.Random;

​

public class main{

public static void main(String[] args) {

    Random rand=new Random();

    int[]numbers=new int[60000000];

    for (int i = 0; i < numbers.length; i++) {

        numbers[i]=rand.nextInt(10000);

    }

    System.out.println("before");

    quickSort(numbers);

    System.out.println("after");

   // printArray(numbers);

}

static void printArray(int []numbers){

    for(int x:numbers){

        System.out.println(x);

    }

}

static void quickSort(int[]numbers){

    quickSort(numbers,0,numbers.length-1);

}

static void quickSort(int[]numbers,int lowIndex,int heighIndex){

if(lowIndex>=heighIndex)return;

int pivotIndex=new Random().nextInt(heighIndex-lowIndex)+lowIndex;

int pivot=numbers[pivotIndex];

int leftPointer=lowIndex;

int righPointer=heighIndex;

swap(numbers, pivotIndex, heighIndex);

while(leftPointer<righPointer){

    while(numbers[leftPointer]<=pivot&&leftPointer<righPointer){

        leftPointer++;

    }

    while(numbers[righPointer]>=pivot&&leftPointer<righPointer){

        righPointer--;

    }

    swap(numbers,leftPointer, righPointer);

}

swap(numbers, leftPointer,heighIndex);

quickSort(numbers,lowIndex,leftPointer-1);

quickSort(numbers, leftPointer+1, heighIndex);

​

}

static void swap(int[]numbers,int index1,int index2){

int  temp=numbers[index1];

numbers[index1]=numbers[index2];

numbers[index2]=temp;

}

​

 }   

Google images trying to find the most random filetypes to use

https://i.kym-cdn.com/entries/icons/mobile/000/038/707/meme9.jpg

import java.util.*;

​

public class Sort {

    static ArrayList<Integer> quicksort(ArrayList<Integer> list) {

        if (list.size() <= 1) {

            return list;

        }

        ArrayList<Integer> lessThanPivot = new ArrayList<Integer>();

        ArrayList<Integer> greaterThanPivot = new ArrayList<Integer>();

        int pivot = list.get(0);

        int length = list.size();

        for (int i = 1; i < length; i++) {

            int currentValue = list.get(i);

            if (currentValue <= pivot) {

                lessThanPivot.add(currentValue);

            } else {

                greaterThanPivot.add(currentValue);

            }

        }

        ArrayList<Integer> sortedList = new ArrayList<Integer>();

        sortedList.addAll(quicksort(lessThanPivot));

        sortedList.add(pivot);

        sortedList.addAll(quicksort(greaterThanPivot));

        return sortedList;

    }

​

    public static void main(String[] args) {

        ArrayList<Integer> list = new ArrayList<Integer>(Arrays.asList(32, 100, 1, 2, 29, 28, 88, 3, 50, 67, 37, 1, 57, 20));

        System.out.println(quicksort(list));

    }

}

static int partition(int[] array , int low , int high){

                int i = (low - 1)  ;

                int pivot = array[high] ;

                for(int j = low ; j < high ; ++j){

                        if(array[j] <= pivot){

                                ++i ;

                                int temp  = array[i] ;

                                array[i] = array[j] ;

                                array[j] = temp ;

                        }

                }

                int temp = array[i+1] ;

                array[i+1]= array[high] ;

                array[high] = temp ;

                return (i+1) ;

        }

​

        static void QuickSort(int[] array , int low , int high){

                if (low < high) {

                        int pi = partition(array , low , high) ;

                        QuickSort(array , low , pi - 1) ;

                        QuickSort(array , pi + 1 , high) ;

                }

        }

​

 public static void main(String[] args) {

    QuickSort(arr , 0 , arr.length -1) ;

 }

// Quick sort in Java

​

import java.util.Arrays;

​

class Quicksort {

​

  // method to find the partition position

  static int partition(int array[], int low, int high) {

    // choose the rightmost element as pivot

    int pivot = array[high];

    // pointer for greater element

    int i = (low - 1);

​

    // traverse through all elements

    // compare each element with pivot

    for (int j = low; j < high; j++) {

      if (array[j] <= pivot) {

​

        // if element smaller than pivot is found

        // swap it with the greatr element pointed by i

        i++;

​

        // swapping element at i with element at j

        int temp = array[i];

        array[i] = array[j];

        array[j] = temp;

      }

​

    }

​

    // swapt the pivot element with the greater element specified by i

    int temp = array[i + 1];

    array[i + 1] = array[high];

    array[high] = temp;

​

    // return the position from where partition is done

    return (i + 1);

  }

​

  static void quickSort(int array[], int low, int high) {

    if (low < high) {

​

      // find pivot element such that

      // elements smaller than pivot are on the left

      // elements greater than pivot are on the right

      int pi = partition(array, low, high);

      // recursive call on the left of pivot

      quickSort(array, low, pi - 1);

​

      // recursive call on the right of pivot

      quickSort(array, pi + 1, high);

    }

  }

}

​

// Main class

class Main {

  public static void main(String args[]) {

​

    int[] data = { 8, 7, 2, 1, 0, 9, 6 };

    System.out.println("Unsorted Array");

    System.out.println(Arrays.toString(data));

​

    int size = data.length;

​

    // call quicksort() on array data

    Quicksort.quickSort(data, 0, size - 1);

​

    System.out.println("Sorted Array in Ascending Order: ");

    System.out.println(Arrays.toString(data));

  }

}