Question

我正在编写一个简单的程序，如果一个数组被排序为false，则返回true，并且我在eclipse中不断获得异常，我只是想不通原因。我想知道是否有人可以查看我的代码并解释为什么我得到一个超出界限的数组。

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

Answer 1

让我们看一下你构建的循环的更简洁版本：

for (i = 0; i < a.length; i++); { 
    if (a[i] < a[i + 1]) {
        return true;
    }
    else {
        return false;
    }
}

我应该首先指出原始循环中的语法错误。也就是说，在大括号（;）之前有一个分号（{）来启动循环体。应该删除该分号。另请注意，我重新格式化了代码的空白区域，使其更具可读性。

现在让我们讨论循环中发生的事情。循环迭代器i从0开始，到a.length - 1结束。由于i用作数组的索引，因此指出a[0]是第一个元素而a[a.length - 1]是数组的最后一个元素。但是，在循环体中，您还编写了i + 1的索引。这意味着如果i等于a.length - 1，则您的索引等于a.length，这超出了数组的范围。

函数isSorted也存在相当大的问题，因为它第一次返回a[i] < a[i+1]时返回true，而第一次返回时则返回false;它实际上并没有检查数组是否完全排序！相反，它只检查前两个条目是否已排序。

具有类似逻辑但检查数组是否真正排序的函数是

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

Answer 2

使用此表达式a[i+1]，您正在运行数组的末尾。

如果必须与下一个元素进行比较，那么请尽早停止迭代1元素（并删除分号，Java将其解释为for循环体）：

// stop one loop early ---v       v--- Remove semicolon here
for(i = 0; i < a.length - 1; i ++){

Answer 3

int i;
for(i = 0; i < a.length - 1 && a[i] < a[i+1]; i++){}
return (i == a.length - 1);

只访问数组元素，结束条件的最后部分不是如果第一部分是假的，则处理
停在第一个未排序的元素

Answer 4

对于使用Java 8及更高版本的人来说，这是一个简单的单行程序：

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

或逻辑等效的替代方案：

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

Answer 5

<a[i+1]当i == a.length会给您错误时

a[i+1]。

例如，在长度为10的数组中，您有元素0到9。

当i为9时，

a[10]会显示for(i=0; i < a.length-1;i++)，这是超出界限的。

修复：

{{1}}

此外，您的代码不会检查整个数组，只要调用return，就会终止检查循环。您只需检查第一个值，只检查第一个值。

AND，你的for循环声明后有一个分号，这也导致了问题

Answer 6

要检查数组是否已排序，我们可以比较数组中的相邻元素。

检查null＆amp;的边界条件。 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;
}

Answer 7

您不应该使用a[i+1]，因为该值可能会也可能不会从阵列中消失。

例如：

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]

要解决此问题，只需提前停止循环。

int i;
for(i = 0; i < a.length - 1; i ++);{

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

        return true;
    }else{
        return false;

    }

}

Answer 8

还会对降序数组进行排序。要考虑升序和降序数组，我使用以下内容：

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

Answer 9

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

此函数检查数组是否按升序排列。

Answer 10

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

Answer 11

如果要检查数组是按DESC还是ASC排序：

boolean IsSorted(float [] temp)
{
    boolean result=true,result2=true;
    for (int i = 0; i < temp.length-1; i++)  
        if (temp[i]< temp[i + 1]) 
                result= false;

    for (int i = 0; i < temp.length-1; i++)  
        if (temp[i] > temp[i + 1])   
            result2= false;

    return result||result2;
}

Answer 12

bool checkSorted(int a[], int n) {
  for (int i = 1; i < n-1; i++) {
    if (a[i] > a[i-1]) {
      return false;
    }
  }
  return true;
}

Answer 13

public static boolean isSorted(int[] a) 
{
    int i,count=0;
    for(i = 0; i < a.length-1; i++);{
        if (a[i] < a[i+1]) {
            count=count+1;
        }  
        }
    if(count==a.length-1)
        return true;
    else
        return false;
}
public static void main(String[] args)
{
    int ar[] = {3,5,6,7};
    System.out.println(isSorted(ar));   
}

这里是检查数组是否排序的代码，如果排序返回true，否则返回false。希望你理解这个方法。

Answer 14

Array.prototype.every

every（）方法测试数组中的所有元素是否都通过了提供的函数实现的测试。

arr.every(function (a, b) {
  return a > b;
});

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

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

检查数组是否已排序，返回true或false

14 个答案: