Überprüfen, ob ein array sortiert ist, true oder false zurückgeben

Ich Schreibe ein einfaches Programm, das nur true zurück, wenn ein array sortiert ist, sonst false und ich bekomme immer eine exception in eclipse, und ich kann einfach nicht herausfinden, warum. Ich Frage mich, wenn jemand könnte einen Blick auf meinen code und erklären, warum ich bin immer ein array out of bounds exception. Danke für Eure Hilfe im Voraus.

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)); 
}

post die Ausnahme
Laufen durch den code. Sie haben 4 Einträge, sollte es einfach sein. i gleich 3 an einem gewissen Punkt, was eine[3+1] versuchen Sie, zuzugreifen?
überprüfen Sie Ihre index-Grenzen
Beachten Sie auch, dass der code nicht tut, was Sie sagen. Es wird true zurückgeben, wenn es zwei oder mehr aufeinander folgenden geordneten Elemente, aber nicht unbedingt alle.
Tipp beginnen Sie Ihre Schleife bei i=1 und vergleichen Sie niedriger sein, wenn die Länge >1

InformationsquelleAutor user2101463 | 2013-10-18

30

Schauen wir uns eine sauberere version der Schleife, die Sie gebaut:
```
for (i = 0; i < a.length; i++); { 
    if (a[i] < a[i + 1]) {
        return true;
    }
    else {
        return false;
    }
}
```
Sollte ich zuerst darauf hinweisen, die syntax-Fehler in der original-Schleife. Nämlich, es ist ein Semikolon (;) vor der geschwungenen Klammer ({) , beginnt der Körper der Schleife. Das Semikolon entfernt werden.
Beachten Sie auch, dass ich neu formatiert white-space der code um Sie lesbarer zu machen.

Nun lassen Sie uns diskutieren, was passiert im Regelkreis. Die loop-iterator i beginnt bei 0 und endet am a.length - 1. Da i Funktionen als index für das array, ist es sinnvoll, darauf hinzuweisen, dass a[0] ist das erste element und a[a.length - 1] das Letzte element deines array. Jedoch, in den Körper der Schleife, die Sie geschrieben haben einen index von i + 1 als gut. Dies bedeutet, dass, wenn i gleich a.length - 1, Ihr index ist gleich a.length die außerhalb der Begrenzungen des Arrays.

Die Funktion isSorted hat auch erhebliche Probleme, da gibt es true zurück das erste mal a[i] < a[i+1], und false, wenn er das erste mal nicht; ergo ist es nicht wirklich überprüfen, ob das array sortiert an alle! Eher, es wird nur geprüft, wenn die ersten beiden Einträge sind sortiert.

Einer Funktion mit ähnlicher Logik, aber das prüft, ob das array richtig sortiert ist
```
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.
}
```
Worst-case-Komplexität ist O(n). Was ist die Durchschnittliche Zeit, in der Komplexität gegeben, die Daten werden nach dem Zufallsprinzip ausgewählt aus einer Normalverteilung? Ist es wirklich O(1)? Scheint, wie eine Reihe von abnehmenden geometrischen Reihe, deren Summe ist ein weiteres geometrischen Reihe, die gibt nur 4 als n Ansätze n → ∞ daher ist O(1). Ist das wahr?
fühlt sich plausibel an jedem Datenpunkt die Veränderung der frühen outing ist 0.5, also die Durchschnittliche Zeit, muss die Komplexität noch viel weniger als O(n)

InformationsquelleAutor Richard Tingle
3

Mit diesem Ausdruck a[i+1] sind, laufen Sie über das Ende des Arrays.

Wenn Sie müssen vergleichen, um das nächste element, dann stoppen Sie Ihre iteration 1 element früh (und zu beseitigen, das Semikolon, der Java interpretieren würde, wie Ihr for loop body):
```
//stop one loop early ---v       v--- Remove semicolon here
for(i = 0; i < a.length - 1; i ++){
```
InformationsquelleAutor rgettman
3
```
int i;
for(i = 0; i < a.length - 1 && a[i] < a[i+1]; i++){}
return (i == a.length - 1);
```
- greift nur auf array-Elemente, Letzte Teil-end-Zustand sind nicht
  verarbeitet, wenn der erste Teil ist falsch
- Stoppt am ersten nicht sortiert element
InformationsquelleAutor Shogun

Prüfen, ob array sortiert ist oder nicht, können wir vergleichen benachbarte Elemente im array.

Überprüfen Randbedingungen 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;
}

InformationsquelleAutor savanibharat

2

a[i+1] wenn i == a.length geben Sie den Fehler zu finden.

Beispielsweise in einem array der Länge 10, Sie haben die Elemente 0 bis 9.

a[i+1] wenn i ist 9, wird sich zeigen a[10], die ist out of bounds.

Beheben:
```
for(i=0; i < a.length-1;i++)
```
Auch, dein code überprüft nicht durch das gesamte array, sobald Rückkehr aufgerufen wird, wird der Check-Schleife beendet.
Sie sind einfach die Kontrolle der erste Wert, und nur der erste Wert.

Ja, du hast ein Semikolon nach deiner for-Schleife Erklärung, die auch Probleme verursachen

Ahhhh! Ich sehe jetzt, Danke für Eure Hilfe

InformationsquelleAutor EyeOfTheHawks

Für alle, die mit Java 8 und höher, hier ist ein einfacher one-liner:

public static boolean isSorted(int[] array) {
    return IntStream.range(0, array.length - 1).noneMatch(i -> array[i] > array[i + 1]);
}

Oder ein logisch gleichwertige alternative:

public static boolean isSorted(int[] array) {
    return IntStream.range(0, array.length - 1).allMatch(i -> array[i] <= array[i + 1]);
}

erste Logik ist nicht richtig.. neue int[]{1, 2, 4, 5, 6, 1} es fällt für das Letzte element.
Vielen Dank für den Hinweis. anyMatch hätte noneMatch.
Willkommen mate 🙂

InformationsquelleAutor Jacob G.

0

Sollten Sie nicht verwenden a[i+1] da dieser Wert möglicherweise oder möglicherweise nicht aus dem array.

Beispiel:
```
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]
```
Dieses Problem zu beheben, stoppen Sie die Schleife ein Anfang.
```
int i;
for(i = 0; i < a.length - 1; i ++);{

    if (a[i] < a[i+1]) {

        return true;
    }else{
        return false;

    }

}
```
ein int-array kann nicht null sein. Auch, während Ihr code löst die Ausnahme, dass es nicht wirklich das erreichen, was die Methode um
Sorry, sind Sie richtig. Behoben.

InformationsquelleAutor dtgee

Einem array ist absteigend sortiert. Berücksichtigt sowohl aufsteigender und absteigender arrays, verwende ich die folgenden:

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;
}

InformationsquelleAutor Samil

0
```
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;
}
```
Diese Funktion prüft, ob das array in Aufsteigender Reihenfolge oder nicht.

Erklären Sie Ihre Antwort bitte?
Herzlich willkommen auf Stack Overflow! Während dieses code-snippet lösen können, die Frage ist, einschließlich einer Erklärung der wie und warum das löst das problem wirklich helfen würde zu verbessern, die Qualität Ihrer post. Denken Sie daran, dass Sie die Beantwortung der Frage für die Leser in der Zukunft, nicht nur die person, die jetzt! Bitte Bearbeiten Ihre Antwort zur Erklärung hinzufügen, und geben Hinweise darauf, welche Einschränkungen und Annahmen anwenden.
Herzlich willkommen auf stack overflow 🙂 schauen Sie Bitte auf Beantworten. Sie sollten einige Informationen, warum dein code löst das problem. Code-nur die Antworten sind nicht nützlich für die Gemeinschaft.

InformationsquelleAutor Bhuvanachandu

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;
}

Hier sollten Sie einige Erläuterungen über den code, so dass die Menschen nicht haben, Sie zu entschlüsseln. Zum Beispiel, was ist i? Wo hast du das erklären? Sie sind Validierung eines Aszendent oder Nachkomme Sortieren? Versuchen Sie, nicht zu Antworten, nur mit code. Überprüfen Sie die Beantworten für weitere details.

InformationsquelleAutor shashi ilakal

-3

Array.der Prototyp.jeder

Den jeder() Methode testet, ob alle Elemente im array den test zu bestehen, umgesetzt von der vorgesehenen Funktion.
```
arr.every(function (a, b) {
  return a > b;
});

var arr = [1,2,3] //true

var arr = [3,2,1] //false
```
aufgefallen war dies eine Frage, über java, aber die überprüfung der src .jeder() Aufschluss geben 😉
Diese Antwort ist falsch, nicht nur weil es für js, sondern auch, weil es nicht das tut, was es tun soll. every Funktions-tests nur ein element in der Zeit, so arg b in diesem Fall ist der index des Elements a. Also die Funktionen nur tests, wenn arr[i] > i. Für [5, 3, 5] es gibt true, während für [0, 1, 2] es gibt false.

InformationsquelleAutor iamwhitebox

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.