QuickSort

package Sort;

import java.util.Scanner;

public class QuickSort {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] arr = new int[in.nextInt()];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = in.nextInt();
        }
        quickSort(arr, 0, arr.length);
        for (int i = 0; i < arr.length; ++i) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    static int partition(int[] arr, int low, int high) {
        //Para comparar, iguala o pivot a posição inicial do array atual.
        int pivot = arr[low];
        /*
        Faz com que tudo comece pelo lugar inicial do arr e
        pelo lugar final do arr.
        */
        int i = low-1, j = high+1;
        //Continua indeterminadamente.
        while (true) {
            //Procura o primeiro item maior ou igual ao pivot.
            //Este começa do inicio e vêm.
            do {
                i++;
            } while (arr[i] < pivot);
            //Procura o primeiro item menor ou igual que o pivot.
            //Este começa do final e volta.
            do {
                j--;
            } while (arr[j] > pivot);
            /*
            retorna o J que conterá o pivot que deverá ser tomado como
            ponto de onde continuaremos.
            */
            if (i >= j) {
                return j;
            }
            /*
                Caso não tenha encontrado um pivot novo para ser retornado,
                fazemos o swap do primeiro item maior que o pivot pela esquerda
                e o menor item que o pivot pela direita.
            */
            int aux = arr[i];
            arr[i] = arr[j];
            arr[j] = aux;
        }
    }

    static  void quickSort(int[] arr, int low, int high){
        /*
            Compara o low atual com o high, se o low for igual ao high significa
            que o trecho analisado do array é atômico e por isso não precisa continuar.
        */
        if(low<high){
            //Descobre onde ficará o novo pivot.
            int pivot = partition(arr, low, high);
            //Faz o sort do que está a esquerda do pivot atual.
            quickSort(arr, low, pivot-1);
            //Faz o sort do que está a direita do pivot atual.
            quickSort(arr, pivot+1, high);
        }
    }
}