Este artigo aborda a implementação em Java de quatro algoritmos de ordenação clássicos: Bolha (Bubble Sort), Rápida (Quick Sort), Inserção (Insertion Sort) e Seleção (Selection Sort).

1. Ordenação por Bolha (Bubble Sort)

O algoritmo percorre repetidamente a lista, compara elementos adjacentes e os troca se estiverem na ordem errada. A cada passagem, o maior elemento "flutua" para o final, sendo excluído das iterações seguintes.

public static void bubbleSort(int[] dados) {
    int n = dados.length;
    for (int i = 0; i < n - 1; i++) {
        boolean trocou = false;
        for (int j = 0; j < n - i - 1; j++) {
            if (dados[j] > dados[j + 1]) {
                int aux = dados[j];
                dados[j] = dados[j + 1];
                dados[j + 1] = aux;
                trocou = true;
            }
        }
        if (!trocou) break; // Otimização: se não houve troca, já está ordenado
    }
}

2. Ordenação Rápida (Quick Sort)

Escolhe um elemento como pivô e particiona o aray em torno dele: elementos menores à esquerda e maiores ou iguais à direita. O processo é repetido recursivamente nas subpartes.

public static void quickSort(int[] arr, int inicio, int fim) {
    if (inicio >= fim) return;
    
    int i = inicio;
    int j = fim;
    int pivo = arr[(inicio + fim) / 2]; // Pivô central
    
    while (i <= j) {
        while (arr[i] < pivo) i++;
        while (arr[j] > pivo) j--;
        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    quickSort(arr, inicio, j);
    quickSort(arr, i, fim);
}

3. Ordenação por Inserção (Insertion Sort)

Constrói a sequência ordenada um elemento por vez, removendo e inserindo cada elemento na posição correta entre os já ordenados.

public static void insertionSort(int[] valores) {
    for (int i = 1; i < valores.length; i++) {
        int chave = valores[i];
        int j = i - 1;
        while (j >= 0 && valores[j] > chave) {
            valores[j + 1] = valores[j];
            j--;
        }
        valores[j + 1] = chave;
    }
}

4. Ordenação por Seleção (Selection Sort)

Divide o array em duas partes: ordenada e não ordenada. A cada iteração, seleciona o menor elemento da parte não ordenada e o troca com o primeiro elemento não ordenado.

public static void selectionSort(int[] lista) {
    for (int i = 0; i < lista.length - 1; i++) {
        int indiceMenor = i;
        for (int j = i + 1; j < lista.length; j++) {
            if (lista[j] < lista[indiceMenor]) {
                indiceMenor = j;
            }
        }
        int temporario = lista[i];
        lista[i] = lista[indiceMenor];
        lista[indiceMenor] = temporario;
    }
}