Algorithme pour trouver le plus grand entier dans la gamme

Un bug lors de la rencontre d' length est impair.

Dans ces cas, vous "ratez" le milieu de l'élément.

Exemple: pour la saisie int[] arr = { 8, 1, 5, 4, 9, 4, 3, 7, 2 }; - l'élément 9 seront comparés et vérifiées par rapport à lui-même, mais alors vous réduisez la taille de length, vous exclure 9 du tableau vous allez pour l'itération suivante.

Je crois qu'il peut être résolu en réduisant le problème à ceil(length/2) au lieu de length/2 (et de manutention cas particulier de length==1)

L'autre problème, comme il a été mentionné dans les commentaires est: vous avez besoin de itérer jusqu'à length/2 plutôt jusqu'à length, sinon vous personnalisez vous-même.

Enfin - le signe est faux.

if(a[i]>a[k])

devrait être

if(a[i]<a[k])

Rappelez - vous que vous essayez de permuter les éléments, si le premier est plus petit que le deuxième dans l'ordre de pousser les grands éléments de la tête de votre tableau.

OriginalL'auteur amit

C'est plutôt un fou pour résoudre le problème, mais je vais jouer le jeu.

Le problème est dans la boucle interne.

• Vous commencez avec i = 0 et k = longueur - 1.
• Si a[i] > [k] vous l'échange.
• ...
• Vous vous retrouvez avec k = 0 et i = longueur - 1
• Si a[i] > [k] vous l'échange.

Si vous regardez attentivement, vous remarquerez que si nous avons échangé les éléments dans le premier échange, nous permettra également d'échanger dans le dernier swap; c'est à dire on va ANNULER les effets de la première swap. Et la même chose s'applique par paire, par le biais de l'ensemble de la tranche de tableau.

Voir?

Ce que vous devez faire est d'arrêter la boucle interne de la moitié du chemin ... et puis prendre en compte le cas où length est impair.

---

Par ailleurs, la raison, j'ai appelé ce "plutôt fou", parce que l'évidence de façon simple et est beaucoup plus rapide: O(N) contre O(NlogN)

OriginalL'auteur Stephen C

Ici est une solution qui s'adapte le cahier des charges que vous voulez (à la différence de beaucoup d'autres ici, humm, humm):

    final Integer[] input = {1, 2, 6, 32, 4, 44 ,12, 42, 3, 7, 17, 22, 57, 23, 102, 103 };
int half = (input.length / 2);
int mod = input.length % 2;
while (half >= 0) {
for (int i = 0, j = (half * 2) + mod - 1; i <= half && j >= half; i++, j--) {
if (input[i] < input[j]) {
final int tmp = input[i];
input[i] = input[j];
input[j] = tmp;
}
}
if (half == 0) break;
half = half / 2;
mod = half % 2;
}
//Here, input[0] = the biggest number in the original input.

Edit: Ajout de mod, de sorte qu'il fonctionne si le dernier élément est le plus important..

OriginalL'auteur Tobb

Pourquoi ne pas tout simplement mettre la première valeur du tableau à une variable max.

Après cela, il suffit parcourir le tableau à partir de la deuxième position jusqu'à la dernière ,
dans la boucle, il suffit de vérifier si la valeur actuelle est supérieure à max ou pas.Si il est plus juste d'attribuer max cette valeur.

Retour max et vous avez le plus grand nombre.

public int FindLargest()
{
int[] num = { 1, 2, 5, 12, 13, 56, 16, 4 };
int max = num[0];
for (int i = 1; i <num.length; i++)
{
if (num[i] > max)
{
max = num[i];
}
}
return max;
}

OriginalL'auteur Priyank Patel

         final int validSampleRates[] = new int[]{
5644800, 2822400, 352800, 192000, 176400, 96000,
88200, 50400, 50000, 4800,47250, 44100, 44056, 37800, 32000, 22050, 16000, 11025, 4800, 8000};
ArrayList <Integer> YourArray = new ArrayList <Integer> ():
for (int smaple : validSampleRates){
YourArray.add(smaple);
}
Integer largest = Collections.max(YourArray);
System.out.println("Largest   " + String.valueOf(largest));

La meilleure façon est d'utiliser des Tableau qui s'étend de la Liste de la Collection ArrayList

OriginalL'auteur Fatih Şennik