Como Verificar se um Array Está Ordenado em Java - Guia Prático

Introdução

Neste laboratório, você aprenderá como verificar se um array de números está ordenado em Java. Exploraremos o conceito fundamental de comparar elementos adjacentes, que é uma ideia central em muitos algoritmos de ordenação. Você aprenderá como verificar tanto a ordem ascendente quanto a descendente, e como lidar com casos em que os elementos são iguais. Ao final deste laboratório, você terá uma sólida compreensão da lógica necessária para determinar se um array está ordenado.

Comparar Elementos Adjacentes para Ordenação

Nesta etapa, começaremos a explorar o conceito fundamental de comparar elementos adjacentes, que é uma ideia central em muitos algoritmos de ordenação. Ordenação (Sorting) é o processo de organizar elementos em uma ordem específica, como ascendente ou descendente.

Imagine que você tem uma lista de números e deseja ordená-los do menor para o maior. Uma maneira simples de começar é olhar para dois números próximos um do outro e decidir qual deve vir primeiro.

Vamos criar um programa Java simples para demonstrar essa ideia. Criaremos uma classe que compara dois números.

Abra o arquivo HelloJava.java no editor WebIDE, se ainda estiver aberto. Modificaremos este arquivo para nosso novo programa.
Substitua todo o conteúdo do arquivo pelo seguinte código:
```
public class CompareNumbers {
    public static void main(String[] args) {
        int number1 = 15;
        int number2 = 10;

        System.out.println("Comparing " + number1 + " and " + number2 + ":");

        if (number1 > number2) {
            System.out.println(number1 + " is greater than " + number2);
        } else if (number1 < number2) {
            System.out.println(number1 + " is less than " + number2);
        } else {
            System.out.println(number1 + " is equal to " + number2);
        }
    }
}
```
Vamos analisar as novas partes deste código:
- public class CompareNumbers: Mudamos o nome da classe para CompareNumbers para refletir melhor o que o programa faz. Lembre-se, o nome do arquivo deve corresponder ao nome da classe, então precisaremos renomear o arquivo mais tarde.
- int number1 = 15; e int number2 = 10;: Essas linhas declaram duas variáveis inteiras, number1 e number2, e atribuem a elas valores iniciais.
- System.out.println("Comparing " + number1 + " and " + number2 + ":");: Esta linha imprime uma mensagem indicando quais números estão sendo comparados.
- if (number1 > number2): Esta é uma instrução if. Ela verifica se a condição dentro dos parênteses (number1 > number2) é verdadeira. Se for, o código dentro das chaves {} imediatamente após a instrução if é executado.
- else if (number1 < number2): Esta é uma instrução else if. Se a condição na instrução if for falsa, esta condição (number1 < number2) é verificada. Se for verdadeira, o código dentro de suas chaves é executado.
- else: Esta é uma instrução else. Se nem a condição if nem a condição else if forem verdadeiras, o código dentro do bloco else é executado.
- System.out.println(...): Essas linhas imprimem mensagens com base no resultado da comparação.
Salve o arquivo (Ctrl+S ou Cmd+S).
Agora, precisamos renomear o arquivo para corresponder ao novo nome da classe. No Terminal, certifique-se de estar no diretório ~/project:
```
cd ~/project
```
Renomeie o arquivo usando o comando mv:
```
mv HelloJava.java CompareNumbers.java
```
Este comando move (renomeia) o arquivo HelloJava.java para CompareNumbers.java.
Agora, compile o novo programa:
```
javac CompareNumbers.java
```
Se a compilação for bem-sucedida, você não deverá ver nenhuma saída.
Finalmente, execute o programa compilado:
```
java CompareNumbers
```
Você deverá ver a saída indicando o resultado da comparação:
```
Comparing 15 and 10:
15 is greater than 10
```

Você criou e executou com sucesso um programa Java que compara dois elementos adjacentes e imprime o resultado. Essa comparação simples é um bloco de construção para algoritmos de ordenação mais complexos.

Verificar Ordem Ascendente e Descendente

Na etapa anterior, aprendemos como comparar dois números. Agora, vamos expandir isso para verificar se um par de números adjacentes está em ordem ascendente ou descendente. Este é outro conceito fundamental ao pensar em ordenação.

Ordem ascendente significa organizar elementos do menor para o maior (por exemplo, 1, 5, 10). Ordem descendente significa organizar elementos do maior para o menor (por exemplo, 10, 5, 1).

Modificaremos nosso programa CompareNumbers.java para verificar essas ordens específicas.

Abra o arquivo CompareNumbers.java no editor WebIDE.

Substitua o código existente pelo seguinte:

public class CheckOrder {
    public static void main(String[] args) {
        int number1 = 15;
        int number2 = 10;

        System.out.println("Checking order of " + number1 + " and " + number2 + ":");

        if (number1 < number2) {
            System.out.println("The numbers are in ascending order.");
        } else if (number1 > number2) {
            System.out.println("The numbers are in descending order.");
        } else {
            System.out.println("The numbers are equal.");
        }
    }
}

Aqui está o que mudamos:

public class CheckOrder: Mudamos o nome da classe novamente para CheckOrder. Precisaremos renomear o arquivo para corresponder.
A condição if agora verifica se number1 é menor que number2. Se for verdadeiro, significa que eles estão em ordem ascendente.
A condição else if verifica se number1 é maior que number2. Se for verdadeiro, eles estão em ordem descendente.
O bloco else lida com o caso em que os números são iguais.

Salve o arquivo (Ctrl+S ou Cmd+S).
No Terminal, certifique-se de estar no diretório ~/project:
```
cd ~/project
```
Renomeie o arquivo para corresponder ao novo nome da classe:
```
mv CompareNumbers.java CheckOrder.java
```
Compile o programa modificado:
```
javac CheckOrder.java
```
Novamente, nenhuma saída significa compilação bem-sucedida.

Execute o programa:

java CheckOrder

Com number1 = 15 e number2 = 10, a saída deve ser:

Checking order of 15 and 10:
The numbers are in descending order.

Vamos modificar rapidamente os números para ver o caso ascendente. Abra CheckOrder.java no editor e altere os valores:

public class CheckOrder {
    public static void main(String[] args) {
        int number1 = 5; // Changed from 15
        int number2 = 8; // Changed from 10

        System.out.println("Checking order of " + number1 + " and " + number2 + ":");

        if (number1 < number2) {
            System.out.println("The numbers are in ascending order.");
        } else if (number1 > number2) {
            System.out.println("The numbers are in descending order.");
        } else {
            System.out.println("The numbers are equal.");
        }
    }
}

Salve o arquivo.
Compile o programa novamente:
```
javac CheckOrder.java
```

Execute o programa:

java CheckOrder

Agora, a saída deve refletir a ordem ascendente:

Checking order of 5 and 8:
The numbers are in ascending order.

Você modificou com sucesso o programa para verificar se dois números adjacentes estão em ordem ascendente ou descendente. Esta é uma etapa crucial para entender como os algoritmos de ordenação determinam a posição correta dos elementos.

Lidar com Elementos Iguais

Nas etapas anteriores, comparamos dois números e verificamos se estavam em ordem ascendente ou descendente. Também incluímos um caso para quando os números são iguais. Nesta etapa, focaremos especificamente em lidar com o cenário em que elementos adjacentes são os mesmos.

Ao ordenar, a ordem dos elementos iguais geralmente não importa para o resultado final ordenado, mas é importante para nossa lógica de comparação identificar corretamente este caso. Nosso programa CheckOrder.java atual já lida com isso com o bloco else. Vamos testar explicitamente este caso.

Abra o arquivo CheckOrder.java no editor WebIDE.

Modifique os valores de number1 e number2 para serem iguais:

public class CheckOrder {
    public static void main(String[] args) {
        int number1 = 7; // Changed to 7
        int number2 = 7; // Changed to 7

        System.out.println("Checking order of " + number1 + " and " + number2 + ":");

        if (number1 < number2) {
            System.out.println("The numbers are in ascending order.");
        } else if (number1 > number2) {
            System.out.println("The numbers are in descending order.");
        } else {
            System.out.println("The numbers are equal.");
        }
    }
}

Salve o arquivo (Ctrl+S ou Cmd+S).
No Terminal, certifique-se de estar no diretório ~/project:
```
cd ~/project
```
Compile o programa modificado:
```
javac CheckOrder.java
```
Nenhuma saída indica compilação bem-sucedida.
Execute o programa:
```
java CheckOrder
```
Com ambos os números definidos como 7, a saída agora deve ser:
```
Checking order of 7 and 7:
The numbers are equal.
```

Isso confirma que nosso programa identifica corretamente quando os dois números adjacentes são iguais. Lidar com este caso é importante para a integridade de nossa lógica de comparação.

No contexto de algoritmos de ordenação, quando elementos adjacentes são iguais, eles já estão em uma ordem relativa válida (tanto ascendente quanto descendente podem ser considerados verdadeiros, dependendo da rigidez, mas normalmente são apenas considerados "iguais" e nenhuma troca é necessária).

Você agora testou com sucesso o caso em que elementos adjacentes são iguais, completando nossa exploração da comparação de dois números adjacentes para fins de ordenação.

Resumo

Neste laboratório, começamos explorando o conceito fundamental de comparação de elementos adjacentes, uma ideia central em algoritmos de ordenação. Aprendemos como criar um programa Java simples para comparar dois números e determinar se um é maior que, menor que ou igual ao outro. Isso envolveu a compreensão da sintaxe básica do Java para declaração de variáveis, atribuição e instruções condicionais (if, else if, else). Também praticamos a modificação de arquivos Java existentes e aprendemos a importância de corresponder o nome da classe ao nome do arquivo.

Com base no conceito de comparação de elementos adjacentes, então estendemos nossa compreensão para verificar a ordem ascendente e descendente dentro de uma sequência de números. Isso envolveu a aplicação da lógica de comparação iterativamente a múltiplos elementos. Finalmente, abordamos o cenário de lidar com elementos iguais durante a verificação de ordenação, garantindo que nossa lógica contabilize corretamente os casos em que elementos adjacentes têm o mesmo valor. Essas etapas forneceram uma compreensão fundamental de como determinar programaticamente se um array está ordenado em Java.