Programme Java pour trier les éléments du tableau par ordre décroissant

Un tableau est une collection du même type de données stockée dans un emplacement mémoire contigu. Array est une classe du package java.until qui fournit un tri prédéfini de manière statique et n'a aucune valeur de retour. Voici la syntaxe de la méthode Arrays.sort() mentionnée ci-dessous -

public static void sort(int[] ar, int from_index, int to_index)

Dans la syntaxe ci-dessus, nous avons

• ar - Abréviation du nom du tableau

• from_index - Nous pouvons l'utiliser comme paramètre facultatif là où le tri doit être exécuté.

• to_index - paramètre facultatif fournissant l'index de l'élément.

Ceci est un exemple

Input :Array = {2, 6, 23, 98, 24, 35, 78}
Output:[98, 78, 35, 24, 23, 6, 2]

Input :Array = {1, 2, 3, 4, 5}
Output:[5, 4, 3, 2, 1]

Aujourd'hui, dans cet article, nous allons apprendre à trier les éléments d'un tableau présents dans une liste et à les réorganiser par ordre décroissant à l'aide de l'environnement Java.

Algorithme de tri des éléments du tableau par ordre décroissant :-

Ici, nous avons écrit un algorithme possible par lequel nous pouvons trier les éléments du tableau par ordre décroissant.

• Étape 1 - Commencer

• Étape 2 - Réglez la température =0.

• Étape 3 - Déclarez un tableau pour contenir les données.

• Étape 4 - Initialisez le tableau en utilisant arr[] ={5, 2, 8, 7, 1}.

• Étape 5 - Imprimer "Éléments du tableau original"

• Étape 6 - Déclarez une variable temporaire pour stocker l'élément lors de l'échange.

• Étape 7 - Utilisez deux boucles for pour atteindre le même objectif.

• Étape 8 - Répétez pour i

• Étape 9 - Utilisez la première boucle for pour enregistrer l'élément et parcourir tous les éléments.

• Étape 10 - if(arr[i]

  temporaire = arr[i]

  arr[i]=arr[j]

  arr[j]=temp

• Étape 11 - Utilisez une seconde boucle for pour comparer avec les éléments restants

• Étape 12 - Imprimez une nouvelle ligne.

• Étape 13 - Trier les éléments par comparaison et échange.

• Étape 14 - Itérer en utilisant for(i=0;i

• Étape 15 - Affichez le tableau mis à jour sous la forme PRINT arr[i].

• Étape 16 - Arrêtez

Syntaxe pour trier les éléments du tableau par ordre décroissant

import java.util.*;
class Tutorialspoint071001 {
   public static void main(String[] args){
     // Initializing the array for the process
     Integer array[] = { 1, 2, 7, 16, 5,6 };

     // Sorting the array in a descending order
     Arrays.sort(array, Collections.reverseOrder());

     // Printing the elements after the process run
     System.out.println(Arrays.toString(array));
   }
}

Méthode à suivre

• Méthode 1 - Programme Java pour trier les éléments par ordre décroissant

• Méthode 2 - Programme Java pour trier les éléments par ordre décroissant à l'aide de la fonction temp

• Méthode 3 - Programme Java pour trier les éléments par ordre décroissant en utilisant une logique commune

Programme Java pour trier les éléments par ordre décroissant

Dans ce code Java, nous essayons de construire la logique d'un processus de tri des éléments d'un tableau par ordre décroissant.

Exemple 1

import java.util.*;
public class tutorialspoint {
   public static void main(String[] args){

      // Initializing the array for the process run
      int array[] = { 1, 2, 3, 7, 5, 16 };

      // Sorting the array in ascending order if needed
      Arrays.sort(array);

      // Reversing the array for the main process
      reverse(array);

      // Printing the elements from the array
      System.out.println(Arrays.toString(array));
   }
   public static void reverse(int[] array){

      // Length of the array is mentioned here
      int n = array.length;

      // Run the process again. Swapping the first half elements with last half elements
      for (int i = 0; i < n / 2; i++) {

         // Storing the first half elements in a temp manner
         int temp = array[i];

         // Assigning the first half to the last half to get result
         array[i] = array[n - i - 1];

         // Assigning the last half to the first half to get the result
         array[n - i - 1] = temp;
      }
   }
}

Sortie

[16, 7, 5, 3, 2, 1]

Programme Java pour trier les éléments par ordre décroissant à l'aide de la fonction temp

Dans ce code Java, nous pouvons utiliser la fonction temp pour construire une logique permettant de trier les éléments du tableau par ordre décroissant.

Exemple 2

import java.util.Scanner;
public class Descendingtutorialspountrddarb{
   public static void main(String[] args) {
      int n, temp;
      Scanner s = new Scanner(System.in);
      System.out.print("Enter no. number of elements you want in the array---->:");
      n = s.nextInt();
      int a[] = new int[n];
      System.out.println("Enter all the elements here now to run the code further ----> :");
      for (int i = 0; i < n; i++) {
         a[i] = s.nextInt();
      }
      for (int i = 0; i < n; i++) {
         for (int j = i + 1; j < n; j++) {
            if (a[i] < a[j]) {
               temp = a[i];
               a[i] = a[j];
               a[j] = temp;
            }
         }
      }
      System.out.print("Descending Order Output Is Here. Have A Look!:");
      for (int i = 0; i < n - 1; i++) {
         System.out.print(a[i] + ",");
      }
      System.out.print(a[n - 1]);
   }
}

Sortie

Enter no. number of elements you want in the array---->:7
Enter all the elements here now to run the code further ----> :
1
2
3
16
4
5
6
Descending Order Output Is Here. Have A Look!:16,6,5,4,3,2,1

Utilisez la logique universelle pour trier les éléments par ordre décroissant

Dans ce code Java, nous avons écrit une logique pour trier les éléments d'un tableau par ordre décroissant en utilisant certaines fonctions courantes.

Exemple 3

public class Tutorialspoint {
   public static void main(String[] args) {
      //Initialize array for the process 
      int [] arr = new int [] {16, 2022, 2001, 1997, 7}; 
      int temp = 0;

      //Displaying elements of an original array to go further
      System.out.println("Elements of original array are ---->: ");
      for (int i = 0; i < arr.length; i++) { 
         System.out.print(arr[i] + " ");
      }

      //Sort the array in descending order. Please go further
      for (int i = 0; i < arr.length; i++) { 
         for (int j = i+1; j < arr.length; j++) { 
            if(arr[i] < arr[j]) {
               temp = arr[i];
               arr[i] = arr[j];
               arr[j] = temp;
            } 
         } 
      }
      System.out.println();
      //Displaying elements of array after sorting process done.
      System.out.println("Elements of array sorted in descending order is here ---->: ");
      for (int i = 0; i < arr.length; i++) { 
         System.out.print(arr[i] + " ");
      }
   }
}

Sortie

Elements of original array are ---->: 
16 2022 2001 1997 7 
Elements of array sorted in descending order is here ---->: 
2022 2001 1997 16 7

Conclusion

Nous avons examiné en détail la question du tri des éléments du tableau. Aujourd'hui, nous utilisons diverses méthodes de tri pour résoudre ce problème grâce à la grammaire et à l'algorithme mentionnés ci-dessus. J'espère que grâce à cet article, vous avez acquis une compréhension générale de la façon de trier les éléments d'un tableau par ordre décroissant à l'aide de l'environnement Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!