Vérifier si un tableau est trié, renvoyer true ou false
J'écris un programme simple qui renvoie true si un tableau est trié sinon false et que je reçois toujours une exception dans Eclipse et que je n'arrive pas à comprendre pourquoi. Je me demandais si quelqu'un pourrait jeter un coup d'oeil sur mon code et expliquer en quelque sorte pourquoi j'obtiens un tableau hors exception. Merci pour votre aide en avance.
public static boolean isSorted(int[] a)
{
int i;
for(i = 0; i < a.length; i ++);{
if (a[i] < a[i+1]) {
return true;
} else {
return false;
}
}
}
public static void main(String[] args)
{
int ar[] = {3,5,6,7};
System.out.println(isSorted(ar));
}
Regardons une version plus propre de la boucle que vous avez construite:
for (i = 0; i < a.length; i++); {
if (a[i] < a[i + 1]) {
return true;
}
else {
return false;
}
}
Je devrais d'abord signaler l'erreur de syntaxe dans la boucle d'origine. À savoir, il y a un point-virgule (;) avant l'accolade ({) qui commence le corps de la boucle. Ce point-virgule doit être supprimé ..__ Notez également que j'ai reformaté l'espace blanc du code pour le rendre plus lisible.
Discutons maintenant de ce qui se passe dans votre boucle. L'itérateur de boucle i commence à 0 et se termine à a.length - 1. Puisque i fonctionne comme un index de votre tableau, il est logique de souligner que a[0] est le premier élément et a[a.length - 1] le dernier élément de votre tableau. Cependant, dans le corps de votre boucle, vous avez également écrit un index de i + 1. Cela signifie que si i est égal à a.length - 1, votre index est égal à a.length, ce qui est en dehors des limites du tableau.
La fonction isSorted a également des problèmes considérables, car elle renvoie true la première fois a[i] < a[i+1] et false la première fois. ergo, il ne vérifie pas réellement si le tableau est trié du tout! Au lieu de cela, il vérifie uniquement si les deux premières entrées sont triées.
Une fonction avec une logique similaire mais qui vérifie si le tableau est vraiment trié est
public static boolean isSorted(int[] a) {
// Our strategy will be to compare every element to its successor.
// The array is considered unsorted
// if a successor has a greater value than its predecessor.
// If we reach the end of the loop without finding that the array is unsorted,
// then it must be sorted instead.
// Note that we are always comparing an element to its successor.
// Because of this, we can end the loop after comparing
// the second-last element to the last one.
// This means the loop iterator will end as an index of the second-last
// element of the array instead of the last one.
for (int i = 0; i < a.length - 1; i++) {
if (a[i] > a[i + 1]) {
return false; // It is proven that the array is not sorted.
}
}
return true; // If this part has been reached, the array must be sorted.
}
Avec cette expression, a[i+1], vous exécutez la fin du tableau.
Si vous devez comparer l'élément suivant, arrêtez votre élément de l'itération 1 plus tôt (et supprimez le point-virgule, que Java interpréterait comme étant votre corps de boucle for):
// stop one loop early ---v v--- Remove semicolon here
for(i = 0; i < a.length - 1; i ++){
int i;
for(i = 0; i < a.length - 1 && a[i] < a[i+1]; i++){}
return (i == a.length - 1);
- accède uniquement aux éléments du tableau, la dernière partie de la condition de fin n'est pas traitée traitée si la première partie est fausse
- s'arrête sur le premier élément non trié
a[i+1] quand i == a.length vous donnera cette erreur.
Par exemple, dans un tableau de longueur 10, vous avez les éléments 0 à 9.
a[i+1] lorsque i vaut 9, affiche a[10], ce qui est hors limites.
Pour réparer:
for(i=0; i < a.length-1;i++)
En outre, votre code ne vérifie pas l'intégralité du tableau, dès que return est appelé, la boucle de vérification est terminée . Vous ne faites que vérifier la première valeur, et uniquement la première.
ET, vous avez un point-virgule après votre déclaration de boucle for, ce qui pose également des problèmes
Pour vérifier si le tableau est trié ou non, nous pouvons comparer les éléments adjacents dans le tableau.
Vérifiez les conditions aux limites de null & a.length == 0
public static boolean isSorted(int[] a){
if(a == null) {
//Depends on what you have to return for null condition
return false;
}
else if(a.length == 0) {
return true;
}
//If we find any element which is greater then its next element we return false.
for (int i = 0; i < a.length-1; i++) {
if(a[i] > a[i+1]) {
return false;
}
}
//If array is finished processing then return true as all elements passed the test.
return true;
}
Pour ceux qui utilisent Java 8 et les versions ultérieures, voici un exemple simple:
public static boolean isSorted(int[] array) {
return IntStream.range(0, array.length - 1).noneMatch(i -> array[i] > array[i + 1]);
}
Ou une alternative logiquement équivalente:
public static boolean isSorted(int[] array) {
return IntStream.range(0, array.length - 1).allMatch(i -> array[i] <= array[i + 1]);
}
Vous ne devez pas utiliser a[i+1] car cette valeur peut ou non disparaître du tableau.
Par exemple:
A = {1, 2, 3}
// A.length is 3.
for(i = 0; i < a.length; i ++) // A goes up to 3, so A[i+1] = A[4]
Pour résoudre ce problème, il suffit d’arrêter la boucle un de bonne heure.
int i;
for(i = 0; i < a.length - 1; i ++);{
if (a[i] < a[i+1]) {
return true;
}else{
return false;
}
}
public static boolean isSorted(int[] a)
{
for ( int i = 0; i < a.length - 1 ; i++ ) {
if ( a[i] > a[i+1] )
return false;
}
return true;
}
Cette fonction vérifie si le tableau est dans l'ordre croissant ou non.
Un tableau descendant est également trié. Pour prendre en compte les tableaux ascendants et descendants, j'utilise ce qui suit:
public static boolean isSorted(int[] a){
boolean isSorted = true;
boolean isAscending = a[1] > a[0];
if(isAscending) {
for (int i = 0; i < a.length-1; i++) {
if(a[i] > a[i+1]) {
isSorted = false;
break;
}
}
} else {//descending
for (int i = 0; i < a.length-1; i++) {
if(a[i] < a[i+1]) {
isSorted = false;
break;
}
}
}
return isSorted;
}
boolean checkElements(int arr[], int first, int last) {
while(arr.length > first) {
if(arr[i] > arr[last-1]) {
if(arr[i] > arr[i+1])
return checkElements(arr, first+1, first+2);;
return false;
}else {
if(arr[i] < arr[i+1])
return checkElements(arr, first+1, first+2);
return false;
}
}
return true;
}