Comment vérifier si un tableau est trié en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un tableau de nombres est trié en Java. Nous explorerons le concept fondamental de comparaison des éléments adjacents, qui est une idée centrale dans de nombreux algorithmes de tri. Vous apprendrez à vérifier à la fois l'ordre croissant et décroissant, et à gérer les cas où les éléments sont égaux. À la fin de ce laboratoire, vous aurez une bonne compréhension de la logique nécessaire pour déterminer si un tableau est trié.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/DataStructuresGroup(["Data Structures"]) java/BasicSyntaxGroup -.-> java/operators("Operators") java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/DataStructuresGroup -.-> java/sorting("Sorting") subgraph Lab Skills java/operators -.-> lab-560004{{"Comment vérifier si un tableau est trié en Java"}} java/if_else -.-> lab-560004{{"Comment vérifier si un tableau est trié en Java"}} java/sorting -.-> lab-560004{{"Comment vérifier si un tableau est trié en Java"}} end

Comparer les éléments adjacents pour le tri

Dans cette étape, nous allons commencer à explorer le concept fondamental de la comparaison des éléments adjacents, qui est une idée centrale dans de nombreux algorithmes de tri. Le tri est le processus d'organisation des éléments dans un ordre spécifique, tel que croissant ou décroissant.

Imaginez que vous avez une liste de nombres et que vous souhaitez les trier du plus petit au plus grand. Une façon simple de commencer est de regarder deux nombres côte à côte et de décider lequel devrait venir en premier.

Créons un simple programme Java pour illustrer cette idée. Nous allons créer une classe qui compare deux nombres.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il est toujours ouvert. Nous allons modifier ce fichier pour notre nouveau programme.
Remplacez tout le contenu du fichier par le code suivant :
```
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);
        }
    }
}
```
Examinons les nouvelles parties de ce code :
- public class CompareNumbers : Nous avons changé le nom de la classe en CompareNumbers pour mieux refléter ce que le programme fait. N'oubliez pas que le nom du fichier doit correspondre au nom de la classe, nous devrons donc renommer le fichier plus tard.
- int number1 = 15; et int number2 = 10; : Ces lignes déclarent deux variables entières, number1 et number2, et leur assignent des valeurs initiales.
- System.out.println("Comparing " + number1 + " and " + number2 + ":"); : Cette ligne affiche un message indiquant quels nombres sont comparés.
- if (number1 > number2) : Il s'agit d'une instruction if. Elle vérifie si la condition entre parenthèses (number1 > number2) est vraie. Si c'est le cas, le code entre les accolades {} qui suit immédiatement l'instruction if est exécuté.
- else if (number1 < number2) : Il s'agit d'une instruction else if. Si la condition de l'instruction if était fausse, cette condition (number1 < number2) est vérifiée. Si elle est vraie, le code entre ses accolades est exécuté.
- else : Il s'agit d'une instruction else. Si ni la condition if ni la condition else if n'étaient vraies, le code dans le bloc else est exécuté.
- System.out.println(...) : Ces lignes affichent des messages en fonction du résultat de la comparaison.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Maintenant, nous devons renommer le fichier pour qu'il corresponde au nouveau nom de classe. Dans le terminal, assurez-vous d'être dans le répertoire ~/project :
```
cd ~/project
```
Renommez le fichier en utilisant la commande mv :
```
mv HelloJava.java CompareNumbers.java
```
Cette commande déplace (renomme) le fichier HelloJava.java en CompareNumbers.java.
Maintenant, compilez le nouveau programme :
```
javac CompareNumbers.java
```
Si la compilation réussit, vous ne devriez voir aucun message de sortie.
Enfin, exécutez le programme compilé :
```
java CompareNumbers
```
Vous devriez voir la sortie indiquant le résultat de la comparaison :
```
Comparing 15 and 10:
15 is greater than 10
```

Vous avez créé et exécuté avec succès un programme Java qui compare deux éléments adjacents et affiche le résultat. Cette simple comparaison est un élément de base pour des algorithmes de tri plus complexes.

Vérifier l'ordre croissant et décroissant

Dans l'étape précédente, nous avons appris à comparer deux nombres. Maintenant, développer cette idée pour vérifier si une paire de nombres adjacents est dans l'ordre croissant ou décroissant. C'est un autre concept fondamental lorsqu'on pense au tri.

L'ordre croissant signifie organiser les éléments du plus petit au plus grand (par exemple, 1, 5, 10). L'ordre décroissant signifie organiser les éléments du plus grand au plus petit (par exemple, 10, 5, 1).

Nous allons modifier notre programme CompareNumbers.java pour vérifier ces ordres spécifiques.

Ouvrez le fichier CompareNumbers.java dans l'éditeur WebIDE.
Remplacez le code existant par le suivant :
```
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.");
        }
    }
}
```
Voici ce que nous avons changé :
- public class CheckOrder : Nous avons de nouveau changé le nom de la classe en CheckOrder. Nous devrons renommer le fichier pour le faire correspondre.
- La condition if vérifie maintenant si number1 est inférieur à number2. Si c'est vrai, cela signifie qu'ils sont dans l'ordre croissant.
- La condition else if vérifie si number1 est supérieur à number2. Si c'est vrai, ils sont dans l'ordre décroissant.
- Le bloc else gère le cas où les nombres sont égaux.
Enregistrez le fichier (Ctrl+S ou Cmd+S).
Dans le terminal, assurez-vous d'être dans le répertoire ~/project :
```
cd ~/project
```
Renommez le fichier pour qu'il corresponde au nouveau nom de classe :
```
mv CompareNumbers.java CheckOrder.java
```
Compilez le programme modifié :
```
javac CheckOrder.java
```
Encore une fois, l'absence de sortie signifie que la compilation a réussi.
Exécutez le programme :
```
java CheckOrder
```
Avec number1 = 15 et number2 = 10, la sortie devrait être :
```
Checking order of 15 and 10:
The numbers are in descending order.
```

Modifions rapidement les nombres pour voir le cas de l'ordre croissant. Ouvrez CheckOrder.java dans l'éditeur et changez les valeurs :

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.");
        }
    }
}

Enregistrez le fichier.
Compilez le programme à nouveau :
```
javac CheckOrder.java
```
Exécutez le programme :
```
java CheckOrder
```
Maintenant, la sortie devrait refléter l'ordre croissant :
```
Checking order of 5 and 8:
The numbers are in ascending order.
```

Vous avez modifié avec succès le programme pour vérifier si deux nombres adjacents sont dans l'ordre croissant ou décroissant. C'est une étape cruciale pour comprendre comment les algorithmes de tri déterminent la position correcte des éléments.

Gérer les éléments égaux

Dans les étapes précédentes, nous avons comparé deux nombres et vérifié s'ils étaient dans l'ordre croissant ou décroissant. Nous avons également inclus un cas pour lorsque les nombres sont égaux. Dans cette étape, nous allons nous concentrer spécifiquement sur la gestion du scénario où les éléments adjacents sont identiques.

Lors du tri, l'ordre des éléments égaux n'a généralement pas d'importance pour le résultat final trié, mais il est important que notre logique de comparaison identifie correctement ce cas. Notre programme actuel CheckOrder.java gère déjà ce cas avec le bloc else. Testons explicitement ce cas.

Ouvrez le fichier CheckOrder.java dans l'éditeur WebIDE.

Modifiez les valeurs de number1 et number2 pour qu'elles soient égales :

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.");
        }
    }
}

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Dans le terminal, assurez-vous d'être dans le répertoire ~/project :
```
cd ~/project
```
Compilez le programme modifié :
```
javac CheckOrder.java
```
L'absence de sortie indique que la compilation a réussi.
Exécutez le programme :
```
java CheckOrder
```
Avec les deux nombres définis à 7, la sortie devrait maintenant être :
```
Checking order of 7 and 7:
The numbers are equal.
```

Cela confirme que notre programme identifie correctement lorsque les deux nombres adjacents sont égaux. Gérer ce cas est important pour la complétude de notre logique de comparaison.

Dans le contexte des algorithmes de tri, lorsque les éléments adjacents sont égaux, ils sont déjà dans un ordre relatif valide (à la fois l'ordre croissant et décroissant peuvent être considérés comme vrais selon la stricte définition, mais généralement ils sont simplement considérés comme "égaux" et aucun échange n'est nécessaire).

Vous avez maintenant testé avec succès le cas où les éléments adjacents sont égaux, achevant ainsi notre exploration de la comparaison de deux nombres adjacents à des fins de tri.

Résumé

Dans ce laboratoire (lab), nous avons commencé par explorer le concept fondamental de la comparaison d'éléments adjacents, une idée centrale dans les algorithmes de tri. Nous avons appris à créer un simple programme Java pour comparer deux nombres et déterminer si l'un est supérieur, inférieur ou égal à l'autre. Cela impliquait de comprendre la syntaxe de base de Java pour la déclaration de variables, l'affectation et les instructions conditionnelles (if, else if, else). Nous avons également pratiqué la modification de fichiers Java existants et appris l'importance de faire correspondre le nom de la classe avec le nom du fichier.

En nous appuyant sur le concept de comparaison d'éléments adjacents, nous avons ensuite élargi notre compréhension pour vérifier à la fois l'ordre croissant et décroissant au sein d'une séquence de nombres. Cela impliquait d'appliquer itérativement la logique de comparaison à plusieurs éléments. Enfin, nous avons abordé le scénario de la gestion des éléments égaux lors de la vérification du tri, en nous assurant que notre logique prend correctement en compte les cas où les éléments adjacents ont la même valeur. Ces étapes ont fourni une compréhension de base de la façon de déterminer par programmation si un tableau est trié en Java.