TOC

Classificação da bolha em Java

Classificação da bolha em Java

1. Introdução

Neste artigo rápido, exploraremos o algoritmo Bubble Sort em detalhes, com foco em uma implementação Java.

Este é um dos algoritmos de classificação mais simples; the core idea is tokeep swapping adjacent elements de um array se eles estiverem em uma ordem incorreta até que a coleção seja classificada.

Pequenos itens são colocados no topo da lista à medida que iteramos a estrutura de dados. Portanto, a técnica é conhecida como tipo de bolha.

Como a classificação é realizada pela troca, podemos dizer que ela realiza a classificação no local.

Além disso,if two elements have same values, resulting data will have their order preserved - o que o torna uma classificação estável.

2. Metodologia

Como mencionado anteriormente, para classificar uma matriz, iteramos através dela, comparando elementos adjacentes e trocando-os, se necessário. Para uma matriz de tamanhon, realizamosn-1 dessas iterações.

Vamos pegar um exemplo para entender a metodologia. Gostaríamos de classificar a matriz em ordem crescente:

4 2 1 6 3 5

Iniciamos a primeira iteração comparando 4 e 2; eles definitivamente não estão na ordem correta. A troca resultaria em:

[2 4] 1 6 3 5

Agora, repetindo o mesmo para 4 e 1:

2[14] 6 3 5

Continuamos fazendo isso até o fim:

2 1 [4 6] 3 5

2 1 4[36] 5

2 1 4 3[5 6]

Como podemos ver, no final da primeira iteração, obtivemos o último elemento em seu devido lugar. Agora, tudo o que precisamos fazer é repetir o mesmo procedimento em outras iterações. Exceto, excluímos os elementos que já estão classificados.

Na segunda iteração, iremos iterar por toda a matriz, exceto pelo último elemento. Da mesma forma, para a terceira iteração, omitimos os últimos 2 elementos. Em geral, para a k-ésima iteração, iteramos até o índicen-k (excluído). No final das iterações den-1, obteremos a matriz classificada.

Agora que você entende a técnica, vamos mergulhar na implementação.

3. Implementação

Vamos implementar a classificação para a matriz de exemplo que discutimos usando a abordagem Java 8: 

void bubbleSort(Integer[] arr) {
    int n = arr.length;
    IntStream.range(0, n - 1)
    .flatMap(i -> IntStream.range(1, n - i))
    .forEach(j -> {
        if (arr[j - 1] > arr[j]) {
            int temp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = temp;
            }
     });
}

E um teste JUnit rápido para o algoritmo: 

@Test
public void whenSortedWithBubbleSort_thenGetSortedArray() {
    Integer[] array = { 2, 1, 4, 6, 3, 5 };
    Integer[] sortedArray = { 1, 2, 3, 4, 5, 6 };
    BubbleSort bubbleSort = new BubbleSort();
    bubbleSort.bubbleSort(array);

    assertArrayEquals(array, sortedArray);
}

4. Complexidade e Otimização

Como podemos ver,for the average and the worst case,the time complexity isO(n^2).

Além disso,the space complexity, mesmo no pior cenário,is O(1) as Bubble sort algorithm doesn’t require any extra memorye a classificação ocorre na matriz original.

Analisando a solução cuidadosamente, podemos ver queif no swaps are found in an iteration, we don’t need to iterate further.

No caso do exemplo discutido anteriormente, após a 2ª iteração, obtemos:

1 2 3 4 5 6

Na terceira iteração, não precisamos trocar nenhum par de elementos adjacentes. Para que possamos pular todas as iterações restantes.

No caso de uma matriz classificada, a troca não será necessária na primeira iteração em si - o que significa que podemos parar a execução. Este é o melhor cenário e otime complexity of the algorithm is O(n).

Agora, vamos implementar a solução otimizada. 

public void optimizedBubbleSort(Integer[] arr) {
    int i = 0, n = arr.length;
    boolean swapNeeded = true;
    while (i < n - 1 && swapNeeded) {
        swapNeeded = false;
        for (int j = 1; j < n - i; j++) {
            if (arr[j - 1] > arr[j]) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
                swapNeeded = true;
            }
        }
        if(!swapNeeded) {
            break;
        }
        i++;
    }
}

Vamos verificar a saída do algoritmo otimizado: 

@Test
public void
  givenIntegerArray_whenSortedWithOptimizedBubbleSort_thenGetSortedArray() {
      Integer[] array = { 2, 1, 4, 6, 3, 5 };
      Integer[] sortedArray = { 1, 2, 3, 4, 5, 6 };
      BubbleSort bubbleSort = new BubbleSort();
      bubbleSort.optimizedBubbleSort(array);

      assertArrayEquals(array, sortedArray);
}

5. Conclusão

Neste tutorial, vimos como o Bubble Sort funciona e sua implementação em Java. Também vimos como isso pode ser otimizado. Para resumir, é um algoritmo estável no local, com complexidade de tempo:

  • Pior e Média: O (n * n), quando a matriz está na ordem inversa

  • Melhor caso: O (n), quando a matriz já está classificada

O algoritmo é popular em computação gráfica, devido à sua capacidade de detectar alguns pequenos erros na classificação. Por exemplo, em uma matriz quase classificada, apenas dois elementos precisam ser trocados, para obter uma matriz completamente classificada. O Bubble Sort pode corrigir esses erros (por exemplo, classificar esse array) em tempo linear.

Como sempre, o código para a implementação deste algoritmo pode ser encontradoover on GitHub.

Related