bubbleort du numéro le plus élevé au plus bas en java

Question

Je cherche un code de bubbleort en java qui est à l'opposé de la chose habituelle que je vois quand je recherche sur internet. Je ne comprends pas vraiment le code ci-dessous, tout ce que je sais, c'est qu'il trie un tas de chiffres du plus bas au plus haut. Est-ce que le code ci-dessous est modifiable de sorte que, au lieu de sortir les numéros du plus bas au plus haut. Il sort le plus élevé au plus bas?

int i; 
    int array[] = {12,9,4,99,120,1,3,10}; 
    System.out.println("Values Before the sort:\n"); 
    for(i = 0; i < array.length; i++) 
     System.out.print(array[i]+" "); 
    System.out.println(); 
    bubble_srt(array, array.length); 
    System.out.print("Values after the sort:\n"); 
    for(i = 0; i <array.length; i++) 
     System.out.print(array[i]+" "); 
    System.out.println(); 
    System.out.println("PAUSE"); 
    } 

    public static void bubble_srt(int a[], int n){ 
    int i, j,t=0; 
    for(i = 0; i < n; i++){ 
     for(j = 1; j < (n-i); j++){ 
     if(a[j-1] > a[j]){ 
      t = a[j-1]; 
      a[j-1]=a[j]; 
      a[j]=t; 
     } 
     } 
    } 
    } 

Answer 1

changement

if(a[j-1] > a[j]){ 

à

if(a[j-1] < a[j]){ 

Answer 2

for(i = array.length -1; i >=0; i--)
{
System.out.println(array[i]);
}

devrait fonctionner. Vous commencez à la fin de la rangée et reculer

Answer 3

vous pouvez changer le bubbleort pour satisfaire vos besoins ou le laisser tel quel et marcher le tableau trié vers l'arrière. pour les deux, vous devriez essayer de comprendre un petit morceau de code au lieu de simplement demander le code modifié.

Answer 4

Quelques mots sur votre code:

Si vous déplacez la méthode d'échange de votre boucle interne, il se est plus lisible et plus facile à raisonner sur les parties indépendantes.

public void swap (int i, int j, int [] arr) { 
    int tmp = arr [i]; 
    arr [i] = arr [j]; 
    arr [j] = tmp; 
} 

Les petites méthodes douces sont faciles à comprendre et à tester, ce qui est important.

Ne déclarez pas les variables d'index en dehors de for. Cela rend plus difficile de raisonner sur votre code - les variables sont visibles sans nécessité en dehors de la boucle. Dans l'ancien code, vous ne gagnez rien en déclarant tmp en dehors de la boucle interne. La déclaration est gratuite à l'exécution.

public static void bubbleSort (int a[], int n) { 
    for (int i = 0; i < n; i++) { 
     for (int j = 1; j < (n-i); j++) { 
      if (a[j-1] > a[j]) { 
       swap (j, j-1, a); 
      } 
     } 
    } 
} 

    // ... missing ... 

Ne vous répétez pas. Déplacer le code dupliqué dans une méthode.

public static void show (int [] arr) 
{ 
    for (int i : arr) 
     System.out.print (i + " "); 
    System.out.println(); 
} 

Les petites méthodes douces sont faciles à tester. Utilisez la boucle forcée simplifiée, dans la mesure du possible, pour éviter les erreurs ponctuelles, et pour être plus robuste aux changements de code - ils fonctionnent aussi pour les listes, par exemple.

int array[] = {12, 9, 4, 99, 120, 1, 3, 10}; 
    System.out.println ("Values Before the sort:\n"); 
    show (array); 
    bubbleSort (array, array.length); 
    System.out.print ("Values after the sort:\n"); 
    show (array); 
    System.out.println ("PAUSE"); 
} 

Avec le code simplifié, il est plus facile de raisonner, quelle partie fait.

if (a[j-1] > a[j]) { 

juste besoin d'être changé

if (a[j-1] < a[j]) { 

pour inverser l'ordre.