Java >> Tutoriel Java >  >> Java

Programme Java pour trier un tableau par ordre décroissant

Java

Dans ce tutoriel, nous allons apprendre à trier les éléments d'un tableau par ordre décroissant. Le tri consiste à organiser les données par ordre alphabétique ou numérique. Mais avant d'aller plus loin, si vous n'êtes pas familier avec les concepts du tableau, alors consultez l'article Tableaux en Java.

Saisie : 5 4 6 7 8 2 3 1 9

Sortie : 9 8 7 6 5 4 3 2 1

Programme 1 :Trier les éléments d'un tableau par ordre décroissant

Dans cette approche, nous verrons comment utiliser des boucles pour trier un tableau par ordre décroissant. Nous pouvons trier le tableau en utilisant le tri manuel comme en utilisant des boucles for. Ce que nous pouvons faire, c'est utiliser deux boucles for, une pour parcourir le tableau depuis le début et une autre boucle for à l'intérieur de la boucle externe pour parcourir l'élément suivant. Dans le corps, nous pouvons comparer les éléments adjacents et échanger s'ils ne sont pas dans l'ordre. Nous pouvons également utiliser une variable temporaire pour l'échange d'éléments.

Algorithme

  1. Démarrer
  2. Déclarer un tableau
  3. Initialiser le tableau
  4. Déclarez une variable temporaire pour stocker les éléments lors de l'échange.
  5. Utilisez deux boucles for pour la même chose.
  6. Utilisez la première boucle for pour contenir les éléments et parcourir tous les éléments.
  7. Utilisez la deuxième boucle for pour comparer avec les éléments restants.
  8. Trier les éléments en comparant et en permutant.
  9. Afficher le tableau mis à jour.
  10. Arrêter

Vous trouverez ci-dessous le code correspondant.

Le programme ci-dessous montre comment trier un tableau dans l'ordre décroissant à l'aide de boucles.

/*Java Program to Sort an Array in Descending Order*/
import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc=new Scanner(System.in);
        int n;    //Array Size Declaration
        System.out.println("Enter the number of elements :");
        n=sc.nextInt();    //Array Size Initialization
        
        Integer arr[]=new Integer[n];    //Array Declaration
        System.out.println("Enter the elements of the array :");
        for(int i=0;i<n;i++)     //Array Initialization
        {
            arr[i]=sc.nextInt();
        }
        
        int temp = 0;    //Temporary variable to store the element
        
         for (int i = 0; i < arr.length; i++)   //Holds each Array element
         {     
            for (int j = i+1; j < arr.length; j++)    //compares with remaining Array elements
            {     
               if(arr[i] < arr[j]) //Compare and swap
               {    
                   temp = arr[i];    
                   arr[i] = arr[j];    
                   arr[j] = temp;    
               }     
            }     
        }    
          
        System.out.println();    
            
        //Displaying elements of array after sorting    
        System.out.println("Elements of array sorted in descending order: ");    
        for (int i = 0; i < arr.length; i++) 
        {     
            System.out.print(arr[i] + " ");    
        }    
    }
}


Saisir le nombre d'éléments :10
Saisir les éléments du tableau :6 7 4 51 2 3 9 77 8 4

Eléments du tableau triés par ordre décroissant :
77 51 9 8 7 6 4 4 3 2

Programme 2 :Trier les éléments d'un tableau par ordre décroissant

Dans cette approche, nous verrons comment utiliser Arrays.sort() et Collections.reverseOrder() pour trier un tableau par ordre décroissant. La classe Arrays du package 'java.util' fournit la méthode de tri qui prend un tableau comme argument et trie le tableau. Il s'agit d'une méthode de tri direct et le tableau peut être trié par ordre croissant avec un seul appel de méthode. Ensuite, lorsque Collections.reverseOrder() est utilisé, il inverse l'ordre du tableau et le tableau résultant est maintenant dans l'ordre décroissant.

Algorithme

  1. Démarrer
  2. Déclarer un tableau
  3. Initialiser le tableau
  4. Utilisez le Arrays.sort() pour trier les éléments par ordre croissant.
  5. Ensuite, utilisez Collections.reverseOrder () pour inverser l'ordre.
  6. Le tableau mis à jour sera désormais dans l'ordre décroissant.
  7. Imprimer le tableau mis à jour.
  8. Arrêter

Vous trouverez ci-dessous le code correspondant.

Un point à noter ici est que Collections.reverseOrder() ne fonctionne pas pour les types primitifs. Nous allons donc définir un tableau avec Integer.

Le programme ci-dessous montre comment trier un tableau dans l'ordre décroissant en utilisant Arrays.sort() et Collections.reverseOrder() 

/*Java Program to Sort an Array in Descending Order*/

import java.util.Arrays; 
import java.util.Collections; 
import java.util.Scanner;

public class Main 
{ 
    public static void main(String[] args) 
    { 
        //Collections.reverseOrder do not work for primitive Types 
        //define an array with Integer
         Scanner sc=new Scanner(System.in);
         System.out.println("Enter the number of elements ");
         Integer n=sc.nextInt();
         System.out.println("Enter the array elements ");
         Integer[] arr=new Integer[n];
         for(int i=0;i<n;i++)
         {
             arr[i]=sc.nextInt();
         }
 
        //print original array
        System.out.printf("Original Array: %s", 
                 Arrays.toString(arr)); 
 
        // Sorts the array in descending order 
        Arrays.sort(arr, Collections.reverseOrder()); 
 
        //print sorted array  
        System.out.printf("\n\nSorted Array: %s", 
               Arrays.toString(arr)); 
    } 
}


Entrez le nombre d'éléments 10
Entrez les éléments du tableau 6 7 4 51 2 3 9 77 8 4
Array d'origine :[6, 7, 4, 51, 2, 3, 9, 77, 8, 4]

Tableau trié :[77, 51, 9, 8, 7, 6, 4, 4, 3, 2]


Balise Java