Introdução

Em Java, diversos algoritmos permitem ordenar arrays de forma eficiente, incluindo Bubble Sort, Selection Sort, Insertion Sort e Quick Sort. Este artigo detalha a implementação de cada um desses métodos.

Bubble Sort

Conceito Fundamental: Este algoritmo percorre o array repetidamente, comparando elementos adjacentes e trocando-os se estiverem na ordem errada. O processo continua até que nenhuma troca seja necessária, fazendo com que os maiores valores "flutuem" para o final da lista.

public class BubbleSortExemplo {
    public static void ordenarBubble(int[] dados) {
        int tamanho = dados.length;
        for (int rodada = 0; rodada < tamanho - 1; rodada++) {
            for (int indice = 0; indice < tamanho - rodada - 1; indice++) {
                if (dados[indice] > dados[indice + 1]) {
                    int temporario = dados[indice];
                    dados[indice] = dados[indice + 1];
                    dados[indice + 1] = temporario;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] conjunto = {63, 4, 24, 1, 3, 13};
        ordenarBubble(conjunto);
        System.out.println(java.util.Arrays.toString(conjunto));
    }
}

Selection Sort

Conceito Fundamental: A cada iteração, este algoritmo encontra o menor elemento na parte não ordenada do array e o troca com o primeiro elemento não ordenado, expandindo gradualmente a porção ordenada.

public class SelectionSortExemplo {
    public static void ordenarSelection(int[] dados) {
        int tamanho = dados.length;
        for (int posicao = 0; posicao < tamanho - 1; posicao++) {
            int menorIndice = posicao;
            for (int j = posicao + 1; j < tamanho; j++) {
                if (dados[j] < dados[menorIndice]) {
                    menorIndice = j;
                }
            }
            int temp = dados[menorIndice];
            dados[menorIndice] = dados[posicao];
            dados[posicao] = temp;
        }
    }

    public static void main(String[] args) {
        int[] valores = {63, 4, 24, 1, 3, 13};
        ordenarSelection(valores);
        System.out.println(java.util.Arrays.toString(valores));
    }
}

Insertion Sort

Conceito Fundamental: Este método constrói um array ordenado incrementalmente, inserindo cada novo elemento na posição correta dentro da parte já ordenada, deslocando elementos maiores para a direita conforme necessário.

public class InsertionSortExemplo {
    public static void ordenarInsertion(int[] dados) {
        int tamanho = dados.length;
        for (int i = 1; i < tamanho; i++) {
            int chave = dados[i];
            int anterior = i - 1;
            while (anterior >= 0 && dados[anterior] > chave) {
                dados[anterior + 1] = dados[anterior];
                anterior--;
            }
            dados[anterior + 1] = chave;
        }
    }

    public static void main(String[] args) {
        int[] dadosExemplo = {20, 40, 90, 30, 80, 70, 50};
        ordenarInsertion(dadosExemplo);
        System.out.println(java.util.Arrays.toString(dadosExemplo));
    }
}

Quick Sort

Conceito Fundamental: Utilizando divisão e conquista, este algoritmo escolhe um pivô, particiona o array em dois subconjuntos (elementos menores e maiores que o pivô), e aplica recursivamente o mesmo processo em cada subconjunto.

public class QuickSortExemplo {
    public static void ordenarQuick(int[] dados, int inicio, int fim) {
        if (inicio < fim) {
            int indicePivo = particionar(dados, inicio, fim);
            ordenarQuick(dados, inicio, indicePivo - 1);
            ordenarQuick(dados, indicePivo + 1, fim);
        }
    }

    private static int particionar(int[] dados, int inicio, int fim) {
        int pivo = dados[fim];
        int i = inicio - 1;
        for (int j = inicio; j < fim; j++) {
            if (dados[j] < pivo) {
                i++;
                trocar(dados, i, j);
            }
        }
        trocar(dados, i + 1, fim);
        return i + 1;
    }

    private static void trocar(int[] dados, int a, int b) {
        int temp = dados[a];
        dados[a] = dados[b];
        dados[b] = temp;
    }

    public static void main(String[] args) {
        int[] array = {49, 38, 65, 97, 76, 13, 27, 49};
        ordenarQuick(array, 0, array.length - 1);
        System.out.println(java.util.Arrays.toString(array));
    }
}