Java- Triez manuellement un tableau de chaînes en utilisant la méthode compareTo()

Permettez-moi d'abord de dire que je sais qu'il existe de meilleurs moyens de trier les emplacements où vous pourriez utiliser autre chose qu'un tableau. C'est une affectation pour la classe où l'utilisateur peut stocker des chaînes dans un tableau, les supprimer, les afficher et les trier. Je suis complètement perdu à l'idée de partir d'ici. J'essaie d'utiliser un tri à bulles et tout fonctionne sauf si la première entrée de mon tableau ne va pas trier. J'évite les exceptions de pointeur nul en filtrant les valeurs nulles, ce qui explique pourquoi mon instruction if est si longue.Java- Triez manuellement un tableau de chaînes en utilisant la méthode compareTo()

private void sortItems(String[] cargohold) { 
    String temp; 
    for (int i = 0; i < cargohold.length - 1; i++) { 
     for (int j = 1; j < cargohold.length; j++) { 
      if (cargohold[i] != null && cargohold[j] != null && (cargohold[i].compareTo(cargohold[j]) < 0)) { 
       temp = cargohold[j]; 
       cargohold[j] = cargohold[i]; 
       cargohold[i] = temp; 
      } 
     } 
    } 
}

J'ai essayé un tas de différentes façons de le faire et je ne peux trouver aucune bonne raison pour laquelle cela ne devrait pas fonctionner. J'ai regardé à travers tout ce que j'ai pu trouver sur Stack Overflow à partir d'exemples et personne n'a le même problème que moi. Pour récapituler, je peux avoir 5 chaînes, "Derp", "Herp", "Sam", "Alfred", "Bill" et ce genre me donnera: "Derp", "Alfred", "Bill" , "Herp", "Sam". Merci d'avance pour les conseils.

Source

2017-09-06 user8570492

Tout d'abord, ce n'est pas une sorte de bulle, il y a le premier numéro – WIR3D

@ WIR3D vous devriez expliquer pourquoi il ne l'est pas. La boucle interne d'un tri à bulles commence normalement à "i + 1", pas à "1". En aparté: s'il vous plaît wirte les parenthèses de tableau après le type, pas la variable ('String [] cargohold' au lieu de' String cargohold [] '). – Turing85

La ligne

if(cargohold[i] != null && cargohold[j] != null && (cargohold[i].compareTo(cargohold[j]) < 0))

devrait être

if(cargohold[j] != null && cargohold[j-1] != null && (cargohold[j].compareTo(cargohold[j-1]) < 0))

et l'échange devrait être fait:

temp = cargohold[j]; 
cargohold[j] = cargohold[j-1]; 
cargohold[j-1] = temp;

Rappelez-vous que dans bubblesort vous comparez éléments adjacents, alors que votre code ne le fait pas.

Flaw

Il y aura des cas où i > j et i < j, mais la logique reste la même swapping, et qui est complètement faux.

Source

2017-09-06 17:45:43

Vous devez également savoir si un élément a été modifié ou non, ce qui vous permet de savoir quand le tri est terminé – WIR3D

@ WIR3D, C'est l'une des optimisations discrètes que vous pouvez faire, mais ce n'est pas le cas ici. –

@SumeetSingh pouvez-vous m'expliquer pourquoi cela fonctionne par opposition à mon code? – user8570492

Votre implémentation est erronée.

Voici tri à bulles (dans un raccourci de type java):

for (index1 = 0; index1 < array.length - 1; ++index1) 
    for (index2 = index1 + 1; index2 < array.length; ++index2) 
     if (array[index1] < array[index1]) 
      swap(array[index1], array[index2]);

noter la index2 = index1 + 1 de la boucle interne.

Source

2017-09-06 18:01:39 DwB

algorithme BubbleSort avec quelques optimisations:

private static void sortItems(String cargohold[]) { 
    String temp; 
    boolean wasSwap = true; 
    for (int index1 = 0; index1 < cargohold.length - 1 && wasSwap; ++index1) { 
     wasSwap = false; 
     for (int index2 = 0; index2 < cargohold.length - index1 - 1; ++index2) { 
      if (cargohold[index2].compareToIgnoreCase(cargohold[index2+1]) > 0) { 
       temp = cargohold[index2]; 
       cargohold[index2] = cargohold[index2+1]; 
       cargohold[index2+1] = temp; 
       wasSwap = true; 
      } 
     } 
    } 
}

complexité moyenne étant O(n^2) avec le meilleur des cas de O(n).

Source

2017-09-06 18:09:53

Java- Triez manuellement un tableau de chaînes en utilisant la méthode compareTo()

Répondre

Questions connexes